1var rng = require('./lib/rng'); 2var bytesToUuid = require('./lib/bytesToUuid'); 3 4// **`v1()` - Generate time-based UUID** 5// 6// Inspired by https://github.com/LiosK/UUID.js 7// and http://docs.python.org/library/uuid.html 8 9var _nodeId; 10var _clockseq; 11 12// Previous uuid creation time 13var _lastMSecs = 0; 14var _lastNSecs = 0; 15 16// See https://github.com/broofa/node-uuid for API details 17function v1(options, buf, offset) { 18 var i = buf && offset || 0; 19 var b = buf || []; 20 21 options = options || {}; 22 var node = options.node || _nodeId; 23 var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; 24 25 // node and clockseq need to be initialized to random values if they're not 26 // specified. We do this lazily to minimize issues related to insufficient 27 // system entropy. See #189 28 if (node == null || clockseq == null) { 29 var seedBytes = rng(); 30 if (node == null) { 31 // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) 32 node = _nodeId = [ 33 seedBytes[0] | 0x01, 34 seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5] 35 ]; 36 } 37 if (clockseq == null) { 38 // Per 4.2.2, randomize (14 bit) clockseq 39 clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; 40 } 41 } 42 43 // UUID timestamps are 100 nano-second units since the Gregorian epoch, 44 // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so 45 // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' 46 // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. 47 var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); 48 49 // Per 4.2.1.2, use count of uuid's generated during the current clock 50 // cycle to simulate higher resolution clock 51 var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; 52 53 // Time since last uuid creation (in msecs) 54 var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000; 55 56 // Per 4.2.1.2, Bump clockseq on clock regression 57 if (dt < 0 && options.clockseq === undefined) { 58 clockseq = clockseq + 1 & 0x3fff; 59 } 60 61 // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new 62 // time interval 63 if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { 64 nsecs = 0; 65 } 66 67 // Per 4.2.1.2 Throw error if too many uuids are requested 68 if (nsecs >= 10000) { 69 throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec'); 70 } 71 72 _lastMSecs = msecs; 73 _lastNSecs = nsecs; 74 _clockseq = clockseq; 75 76 // Per 4.1.4 - Convert from unix epoch to Gregorian epoch 77 msecs += 12219292800000; 78 79 // `time_low` 80 var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; 81 b[i++] = tl >>> 24 & 0xff; 82 b[i++] = tl >>> 16 & 0xff; 83 b[i++] = tl >>> 8 & 0xff; 84 b[i++] = tl & 0xff; 85 86 // `time_mid` 87 var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff; 88 b[i++] = tmh >>> 8 & 0xff; 89 b[i++] = tmh & 0xff; 90 91 // `time_high_and_version` 92 b[i++] = tmh >>> 24 & 0xf | 0x10; // include version 93 b[i++] = tmh >>> 16 & 0xff; 94 95 // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) 96 b[i++] = clockseq >>> 8 | 0x80; 97 98 // `clock_seq_low` 99 b[i++] = clockseq & 0xff; 100 101 // `node` 102 for (var n = 0; n < 6; ++n) { 103 b[i + n] = node[n]; 104 } 105 106 return buf ? buf : bytesToUuid(b); 107} 108 109module.exports = v1; 110