Merge pull request #21 from danakt/release/v4

Vesion 4.0

Author: danakt

.eslintrc

@@ -0,0 +1,10 @@
+{
+ "env": {
+ "browser": true,
+ "node": true
+ },
+ "parserOptions": {
+ "ecmaVersion": 5
+ },
+ "ignorePatterns": "tests"
+}

.github/workflows/node.js.yml

@@ -0,0 +1,25 @@
+name: Node.js CI
+
+on:
+ push:
+ branches: ['master']
+ pull_request:
+ branches: ['master']
+
+jobs:
+ test:
+ runs-on: ubuntu-latest
+
+ strategy:
+ matrix:
+ node-version: [12.x, 14.x, 16.x]
+
+ steps:
+ - uses: actions/checkout@v3
+ - name: Use Node.js ${{ matrix.node-version }}
+ uses: actions/setup-node@v3
+ with:
+ node-version: ${{ matrix.node-version }}
+ cache: 'npm'
+ - run: npm i
+ - run: npm test

.travis.yml

@@ -1,3 +1,3 @@
 language: node_js
 node_js:
- - '8'
+ - '14'

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 Danakt Frost
+Copyright (c) 2020 Danakt Saushkin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -45,7 +45,7 @@ const uuidV5Hash = getUuid('Hello world!', 5);
 `getUuid(name [, namespace, version]);`
 
 - `name` — hashing target
-- `namespace` _Optional_ — namespace in which generation occurs
+- `namespace` _Optional_ — UUID namespace
 - `version` _Optional_ — 3 or 5, version of UUID
 
 ## License

package.json

@@ -1,12 +1,13 @@
 {
  "name": "uuid-by-string",
- "version": "3.0.7",
+ "version": "4.0.0",
  "description": "Generating uuid-hash from string",
  "main": "src/index.js",
  "typings": "index.d.ts",
  "scripts": {
  "test": "jest",
- "prepublishOnly": "jest"
+ "lint": "eslint",
+ "prepublishOnly": "npm run lint && npm run test"
  },
  "repository": {
  "type": "git",
@@ -23,7 +24,7 @@
  "md5",
  "sha-1"
  ],
- "author": "Danakt Frost",
+ "author": "Danakt Saushkin",
  "license": "MIT",
  "bugs": {
  "url": "https://github.com/Danakt/uuid-by-string/issues"
@@ -43,6 +44,7 @@
  "js-sha1": "^0.6.0"
  },
  "devDependencies": {
+ "eslint": "^8.23.0",
  "jest": "^27.0.1"
  }
 }

src/index.js

@@ -31,13 +31,11 @@ function generateUuid(target, namespace, version) {
  }
 
  // Parsing target chars
- var charBuffer = lib.stringToCharBuffer(target);
-
- // TODO: Test namespace for uuid and parse to buffer
- var namespaceCharBuffer = typeof namespace === 'string' ? lib.stringToCharBuffer(namespace) : EMPTY_UINT8_ARRAY;
+ var targetCharBuffer = lib.stringToCharBuffer(target);
+ var namespaceCharBuffer = typeof namespace === 'string' ? lib.parseUuid(namespace) : EMPTY_UINT8_ARRAY;
 
  // Concatenation two buffers of strings to one
- var buffer = lib.concatBuffers(namespaceCharBuffer, charBuffer);
+ var buffer = lib.concatBuffers(namespaceCharBuffer, targetCharBuffer);
 
  // Getting hash
  var hash = version === 3 ? lib.md5Hash(buffer) : lib.sha1Hash(buffer);

src/lib.js

@@ -4,12 +4,31 @@ var sha1 = require('js-sha1');
 /** List of hex digit for fast accessing by index */
 var HEX_DIGITS = '0123456789abcdef'.split('');
 
+/** Length of string containing uuid */
+var UUID_LENGTH = 36;
+
+/** Regular expression for uuid testing */
+var UUID_REGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+
+/** Map matching of hex number and corresponding byte */
+var HEX_TO_BYTE_MAP = (function () {
+ var map = {};
+
+ for (var i = 0; i < 256; i++) {
+ var hex = i.toString(16);
+
+ map[hex.length === 1 ? '0' + hex : hex] = i;
+ }
+
+ return map;
+})();
+
 /**
  * Converts unsigned byte to hex representation
  * @param {number} ubyte The unsigned byte to convert
  * @returns {string} The hex representation
  */
-var uint8ToHex = function(ubyte) {
+var uint8ToHex = function (ubyte) {
  var first = ubyte >> 4;
  var second = ubyte - (first << 4);
 
@@ -21,26 +40,27 @@ var uint8ToHex = function(ubyte) {
  * @param {Uint8Array} buf The unsigned bytes buffer
  * @returns {string} The hex string representation
  */
-var uint8ArrayToHex = function(buf) {
- var out = [];
+var uint8ArrayToHex = function (buf) {
+ var out = '';
 
  for (var i = 0; i < buf.length; i++) {
- out.push(uint8ToHex(buf[i]));
+ out += uint8ToHex(buf[i]);
  }
 
- return out.join('');
+ return out;
 };
 
 /**
  * Converts string to buffer of char codes
  * @param {string} str The string to parse
  * @returns {Uint8Array} Buffer of char codes
  */
-var stringToCharBuffer = function(str) {
- var buffer = new Uint8Array(str.length);
+var stringToCharBuffer = function (str) {
+ var escapedStr = unescape(encodeURIComponent(str));
+ var buffer = new Uint8Array(escapedStr.length);
 
- for (var i = 0; i < str.length; i++) {
- buffer[i] = str[i].charCodeAt(0);
+ for (var i = 0; i < escapedStr.length; i++) {
+ buffer[i] = escapedStr[i].charCodeAt(0);
  }
 
  return buffer;
@@ -51,7 +71,7 @@ var stringToCharBuffer = function(str) {
  * @param {Uint8Array} buf Buffer of char codes
  * @returns {Uint8Array} MD5 hash buffer
  */
-var md5Hash = function(buf) {
+var md5Hash = function (buf) {
  return new Uint8Array(md5.arrayBuffer(buf));
 };
 
@@ -60,7 +80,7 @@ var md5Hash = function(buf) {
  * @param {Uint8Array} buf Buffer of char codes
  * @returns {Uint8Array} SHA-1 hash buffer
  */
-var sha1Hash = function(buf) {
+var sha1Hash = function (buf) {
  return new Uint8Array(sha1.arrayBuffer(buf));
 };
 
@@ -70,7 +90,7 @@ var sha1Hash = function(buf) {
  * @param {Uint8Array} buf2 The second buffer to concatenate
  * @returns {Uint8Array} Concatenation result
  */
-var concatBuffers = function(buf1, buf2) {
+var concatBuffers = function (buf1, buf2) {
  var out = new Uint8Array(buf1.length + buf2.length);
 
  out.set(new Uint8Array(buf1), 0);
@@ -79,44 +99,81 @@ var concatBuffers = function(buf1, buf2) {
  return out;
 };
 
+/**
+ * Validates UUID
+ * @param {string} uuid UUID to validate
+ * @return {boolean} Validation result
+ */
+var validateUuid = function (uuid) {
+ return typeof uuid === 'string' && uuid.length === UUID_LENGTH && UUID_REGEXP.test(uuid);
+};
+
+/**
+ * Parses UUID into a buffer
+ * @param {string} uuid UUID to parse
+ * @returns {Uint8Array} Ready buffer
+ */
+var parseUuid = function (uuid) {
+ if (!validateUuid(uuid)) {
+ throw TypeError('Invalid UUID');
+ }
+
+ var buf = new Uint8Array(16);
+ var strIndex = 0;
+ var bufIndex = 0;
+
+ while (strIndex < uuid.length) {
+ if (uuid[strIndex] === '-') {
+ strIndex++;
+ continue;
+ }
+
+ var oct = (uuid[strIndex] + uuid[strIndex + 1]).toLowerCase();
+ buf[bufIndex] = HEX_TO_BYTE_MAP[oct];
+
+ bufIndex++;
+ strIndex += 2;
+ }
+
+ return buf;
+};
+
 /**
  * Creates uuid from hash buffer
  * @param {Uint8Array} hashBuffer Hash buffer
  * @param {3|5} version Version of uuid
  * @returns {string} The uuid
  */
-var hashToUuid = function(hashBuffer, version) {
- return [
+var hashToUuid = function (hashBuffer, version) {
+ return (
  // The low field of the timestamp
- uint8ArrayToHex(hashBuffer.slice(0, 4)),
- '-',
-
+ uint8ArrayToHex(hashBuffer.slice(0, 4)) +
+ '-' +
  // The middle field of the timestamp
- uint8ArrayToHex(hashBuffer.slice(4, 6)),
- '-',
-
+ uint8ArrayToHex(hashBuffer.slice(4, 6)) +
+ '-' +
  // The high field of the timestamp multiplexed with the version number
- uint8ToHex((hashBuffer[6] & 0x0f) | parseInt(version * 10, 16)),
- uint8ToHex(hashBuffer[7]),
- '-',
-
+ uint8ToHex((hashBuffer[6] & 0x0f) | parseInt(version * 10, 16)) +
+ uint8ToHex(hashBuffer[7]) +
+ '-' +
  // The high field of the clock sequence multiplexed with the variant
- uint8ToHex((hashBuffer[8] & 0x3f) | 0x80),
+ uint8ToHex((hashBuffer[8] & 0x3f) | 0x80) +
  // The low field of the clock sequence
- uint8ToHex(hashBuffer[9]),
- '-',
+ uint8ToHex(hashBuffer[9]) +
+ '-' +
  // The spatially unique node identifier
-
  uint8ArrayToHex(hashBuffer.slice(10, 16))
- ].join('');
+ );
 };
 
 module.exports = {
- uint8ToHex,
- uint8ArrayToHex,
- stringToCharBuffer,
- md5Hash,
- sha1Hash,
- concatBuffers,
- hashToUuid
+ uint8ToHex: uint8ToHex,
+ uint8ArrayToHex: uint8ArrayToHex,
+ stringToCharBuffer: stringToCharBuffer,
+ md5Hash: md5Hash,
+ sha1Hash: sha1Hash,
+ concatBuffers: concatBuffers,
+ validateUuid: validateUuid,
+ parseUuid: parseUuid,
+ hashToUuid: hashToUuid,
 };