simpleflakes 2.2.1 → 3.0.0

package/README.md

@@ -1,24 +1,27 @@
 # simpleflakes
 
-[![travis status][travis-badge]][travis-link]
+[![CI](https://github.com/leodutra/simpleflakes/actions/workflows/ci.yml/badge.svg)](https://github.com/leodutra/simpleflakes/actions/workflows/ci.yml)
 [![npm][npm-badge]][npm-link]
+[![npm downloads](https://img.shields.io/npm/dm/simpleflakes.svg?style=flat)](https://www.npmjs.com/package/simpleflakes)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/simpleflakes?style=flat)](https://bundlephobia.com/package/simpleflakes)
+[![Performance](https://img.shields.io/badge/performance-8.8M%20ops%2Fsec-brightgreen?style=flat&logo=javascript)](https://github.com/leodutra/simpleflakes/actions/workflows/ci.yml)
+[![Node.js](https://img.shields.io/badge/node-%3E%3D16.0.0-brightgreen.svg?style=flat)](https://nodejs.org/)
+[![Dependencies](https://img.shields.io/badge/dependencies-0-green.svg?style=flat)](https://www.npmjs.com/package/simpleflakes)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+[![Last Commit](https://img.shields.io/github/last-commit/leodutra/simpleflakes.svg?style=flat)](https://github.com/leodutra/simpleflakes)
 <!-- [![codacy quality][codacy-quality-badge]][codacy-quality-link]
 [![codacy coverage][codacy-coverage-badge]][codacy-coverage-link] -->
 [![coveralls status][coveralls-badge]][coveralls-link] [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fleodutra%2Fsimpleflakes.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fleodutra%2Fsimpleflakes?ref=badge_shield)
- 
-[![tonicdev demo][demo-tonicdev-badge]][demo-tonicdev-link]
-[![david dep status][dependencies-badge]][dependencies-url]
-[![david dev dep status][dependencies-dev-badge]][dependencies-dev-url]  
 
 Simpleflake is the smartest way to generate a 64-bit + time-ordered + snowflake based ID. [See the presentation!](http://akmanalp.com/simpleflake_presentation/)
 
 ### Test-driven, pure JavaScript
-This port is test-driven and no release goes out without tests.  
+This port is test-driven and no release goes out without tests.
 **Also, this library does not rely on low-level bindings, with OpenSSL, libgmp or anything beyond pure JavaScript.**
 
-Assumes [original Python implementation](https://simpleflake.readthedocs.org/en/latest/) as reference and fixes epoch (starts on `2000-01-01T00:00:00.000Z` (UTC) while Python API v0.1.5 epoch starts on `2000-01-01T05:00:00.000Z`).  
+Assumes [original Python implementation](https://simpleflake.readthedocs.org/en/latest/) as reference and fixes epoch (starts on `2000-01-01T00:00:00.000Z` (UTC) while Python API v0.1.5 epoch starts on `2000-01-01T05:00:00.000Z`).
 
-**simpleflakes** uses the TC39 BigInt implementation when running on newer versions of Node.js. When BigInt is not available, [Fedor Indutny's big number library (bn.js)](https://github.com/indutny/bn.js) is used as the fastest fallback for big number calculations.
+**simpleflakes** uses the TC39 BigInt implementation for fast and reliable 64-bit ID generation in pure JavaScript.
 
 ### How to Install:
 
@@ -33,30 +36,50 @@ const { simpleflake } = require('simpleflakes');
 const flakeBigInt = simpleflake()
 
 // simpleflake(
-//    timestamp = Date.now(), 
-//    random_bits = 23-bit random, 
+//    timestamp = Date.now(),
+//    random_bits = 23-bit random,
 //     epoch = Date.UTC(2000, 0, 1)
 // )
-// returns BigInt on newer Node.js or bn.js BigNum on older engines.
+// returns BigInt
 
 flakeBigInt.toString();       // 4234673179811182512
 flakeBigInt.toString(16);     // 3ac494d21e84f7b0
 flakeBigInt.toString(2);      // 11101011000100...
 flakeBigInt.toString(36);     // 20rfh5
 ```
-You can check the [original Python API 0.1.5](https://simpleflake.readthedocs.org/en/latest/) documentation for more info.  
+
+### TypeScript Support:
+The library is written in TypeScript and includes full type definitions:
+
+```typescript
+import { simpleflake, SimpleFlakeStruct, parseSimpleflake } from 'simpleflakes';
+
+// Generate a typed ID
+const flakeId: bigint = simpleflake();
+
+// Parse with full type safety
+const parsed: SimpleFlakeStruct = parseSimpleflake(flakeId);
+console.log(parsed.timestamp);   // string
+console.log(parsed.randomBits);  // string
+
+// All functions have proper type annotations
+const binaryStr: string = binary(flakeId);
+const bits: bigint = extractBits(flakeId, 23n, 41n);
+```
+
+You can check the [original Python API 0.1.5](https://simpleflake.readthedocs.org/en/latest/) documentation for more info.
 
 
 ### Reference
 ```js
 // Main flake function and its defaults
 simpleflake(
-    timestamp = Date.now(), 
-    random_bits = 23-bit random, 
+    timestamp = Date.now(),
+    random_bits = 23-bit random,
     epoch = Date.UTC(2000, 0, 1)
 )
 
-// Static constant epoch for simpleflake timestamps, starts at the year 2000  
+// Static constant epoch for simpleflake timestamps, starts at the year 2000
 simpleflake.SIMPLEFLAKE_EPOCH // const = 946702800
 
 // Show binary digits of a number, pads to 64 bits unless specified.
@@ -75,31 +98,49 @@ simpleflake.simpleflakeStruct
 SimpleFlake.SimpleFlakeStruct
 ```
 
+### Development:
+
+This project is written in TypeScript and includes comprehensive test coverage.
+
+```sh
+# Install dependencies
+npm install
+
+# Build TypeScript to JavaScript
+npm run build
+
+# Run tests (automatically builds first)
+npm test
+
+# Run with coverage
+npm run test:coverage
+
+# Test module compatibility (CommonJS, ES Modules, TypeScript)
+npm run test:compatibility
+
+# Run all CI tests (coverage + compatibility)
+npm run test:ci
+
+# Type checking
+npm run type-check
+
+# Clean build artifacts
+npm run clean
+```
+
+### License:
 
-### License:  
 [MIT](https://raw.githubusercontent.com/leodutra/simpleflakes/master/LICENSE)
 
 [npm-badge]: https://img.shields.io/npm/v/simpleflakes.svg?style=flat
-[travis-badge]: http://img.shields.io/travis/leodutra/simpleflakes.svg?style=flat
 [codacy-coverage-badge]: https://api.codacy.com/project/badge/Coverage/f71ef817e5f14a9ab3b8b2cb6fabf51a
 [codacy-quality-badge]: https://api.codacy.com/project/badge/Grade/f71ef817e5f14a9ab3b8b2cb6fabf51a
 [coveralls-badge]: https://img.shields.io/coveralls/leodutra/simpleflakes.svg?style=flat
 
 [npm-link]: https://www.npmjs.com/package/simpleflakes
-[travis-link]: https://travis-ci.org/leodutra/simpleflakes
 [codacy-quality-link]: https://www.codacy.com/app/leodutra/simpleflakes
-
 [codacy-coverage-link]: https://www.codacy.com/app/leodutra/simpleflakes?utm_source=github.com&utm_medium=referral&utm_content=leodutra/simpleflakes&utm_campaign=Badge_Coverage
-[codacy-quality-link]: https://www.codacy.com/app/leodutra/simpleflakes?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=leodutra/simpleflakes&amp;utm_campaign=Badge_Grade
 [coveralls-link]: https://coveralls.io/github/leodutra/simpleflakes
-[demo-tonicdev-link]: https://tonicdev.com/leodutra/simpleflakes-demo/1.0.13
-
-[dependencies-url]: https://david-dm.org/leodutra/simpleflakes
-[dependencies-badge]: 	https://img.shields.io/david/leodutra/simpleflakes.svg?style=flat
-[dependencies-dev-url]: https://david-dm.org/leodutra/simpleflakes#info=devDependencies&view=table
-[dependencies-dev-badge]: 	https://img.shields.io/david/dev/leodutra/simpleflakes.svg?style=flat
-[demo-tonicdev-badge]: https://img.shields.io/badge/demo-%40tonicdev-008bb8.svg?style=flat
-
 
 
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fleodutra%2Fsimpleflakes.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fleodutra%2Fsimpleflakes?ref=badge_large)

package/dist/simpleflakes.d.ts

@@ -0,0 +1,51 @@
+declare const SIMPLEFLAKE_EPOCH = 946684800000;
+/**
+ * Generates a simpleflake ID
+ * @param ts - Timestamp in milliseconds (defaults to current time)
+ * @param randomBits - Random bits for the ID (defaults to a random value)
+ * @param epoch - Epoch timestamp in milliseconds (defaults to SIMPLEFLAKE_EPOCH)
+ * @returns Generated simpleflake as a BigInt
+ */
+export declare function simpleflake(ts?: number, randomBits?: number, epoch?: number): bigint;
+/**
+ * Converts a value to binary representation
+ * @param value - The value to convert to binary
+ * @param padding - Whether to pad to 64 bits (defaults to true)
+ * @returns Binary string representation
+ */
+export declare function binary(value: bigint | number | string, padding?: boolean): string;
+/**
+ * Extracts bits from a data value
+ * @param data - The data to extract bits from
+ * @param shift - Number of bits to shift
+ * @param length - Number of bits to extract
+ * @returns Extracted bits as a BigInt
+ */
+export declare function extractBits(data: bigint | number | string, shift: bigint | number, length: bigint | number): bigint;
+/**
+ * Structure representing a parsed simpleflake
+ */
+export declare class SimpleFlakeStruct {
+    readonly timestamp: string;
+    readonly randomBits: string;
+    constructor(timestamp: string, randomBits: string);
+}
+/**
+ * Parses a simpleflake into its components
+ * @param flake - The simpleflake to parse
+ * @returns SimpleFlakeStruct containing timestamp and random bits
+ */
+export declare function parseSimpleflake(flake: bigint | number | string): SimpleFlakeStruct;
+export declare const simpleflakeStruct: typeof SimpleFlakeStruct;
+export { SIMPLEFLAKE_EPOCH };
+declare const _default: {
+    SimpleFlakeStruct: typeof SimpleFlakeStruct;
+    simpleflakeStruct: typeof SimpleFlakeStruct;
+    extractBits: typeof extractBits;
+    parseSimpleflake: typeof parseSimpleflake;
+    binary: typeof binary;
+    SIMPLEFLAKE_EPOCH: number;
+    simpleflake: typeof simpleflake;
+};
+export default _default;
+//# sourceMappingURL=simpleflakes.d.ts.map

package/dist/simpleflakes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleflakes.d.ts","sourceRoot":"","sources":["../src/simpleflakes.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,iBAAiB,eAAe,CAAC;AAWvC;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,EAAE,GAAE,MAAmB,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,GAAE,MAA0B,GAAG,MAAM,CAGnH;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,OAAO,GAAE,OAAc,GAAG,MAAM,CAKvF;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAInH;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B,SAAgB,SAAS,EAAE,MAAM,CAAC;IAClC,SAAgB,UAAU,EAAE,MAAM,CAAC;gBAEvB,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAOlD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAQnF;AAGD,eAAO,MAAM,iBAAiB,0BAAoB,CAAC;AAGnD,OAAO,EAAE,iBAAiB,EAAE,CAAC;;;;;;;;;;AAG7B,wBAWE"}

package/dist/simpleflakes.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMPLEFLAKE_EPOCH = exports.simpleflakeStruct = exports.SimpleFlakeStruct = void 0;
+exports.simpleflake = simpleflake;
+exports.binary = binary;
+exports.extractBits = extractBits;
+exports.parseSimpleflake = parseSimpleflake;
+const SIMPLEFLAKE_EPOCH = 946684800000; // Date.UTC(2000, 0, 1) == epoch ms, since 1 Jan 2000 00:00
+exports.SIMPLEFLAKE_EPOCH = SIMPLEFLAKE_EPOCH;
+const UNSIGNED_23BIT_MAX = 8388607; // (Math.pow(2, 23) - 1) >> 0
+const SIMPLEFLAKE_TIMESTAMP_LENGTH = 41n;
+const SIMPLEFLAKE_RANDOM_LENGTH = 23n;
+const SIMPLEFLAKE_RANDOM_SHIFT = 0n;
+const SIMPLEFLAKE_TIMESTAMP_SHIFT = 23n;
+const CACHE_64_BIT_ZEROS = '0000000000000000000000000000000000000000000000000000000000000000';
+/**
+ * Generates a simpleflake ID
+ * @param ts - Timestamp in milliseconds (defaults to current time)
+ * @param randomBits - Random bits for the ID (defaults to a random value)
+ * @param epoch - Epoch timestamp in milliseconds (defaults to SIMPLEFLAKE_EPOCH)
+ * @returns Generated simpleflake as a BigInt
+ */
+function simpleflake(ts = Date.now(), randomBits, epoch = SIMPLEFLAKE_EPOCH) {
+    return ((BigInt(ts) - BigInt(epoch)) << SIMPLEFLAKE_TIMESTAMP_SHIFT) +
+        BigInt(randomBits ?? Math.round(Math.random() * UNSIGNED_23BIT_MAX));
+}
+/**
+ * Converts a value to binary representation
+ * @param value - The value to convert to binary
+ * @param padding - Whether to pad to 64 bits (defaults to true)
+ * @returns Binary string representation
+ */
+function binary(value, padding = true) {
+    const binValue = BigInt(value).toString(2);
+    return padding && binValue.length < 64
+        ? CACHE_64_BIT_ZEROS.substr(0, 64 - binValue.length) + binValue
+        : binValue;
+}
+/**
+ * Extracts bits from a data value
+ * @param data - The data to extract bits from
+ * @param shift - Number of bits to shift
+ * @param length - Number of bits to extract
+ * @returns Extracted bits as a BigInt
+ */
+function extractBits(data, shift, length) {
+    const shiftN = BigInt(shift);
+    const bitmask = ((1n << BigInt(length)) - 1n) << shiftN;
+    return (BigInt(data) & bitmask) >> shiftN;
+}
+/**
+ * Structure representing a parsed simpleflake
+ */
+class SimpleFlakeStruct {
+    constructor(timestamp, randomBits) {
+        if (timestamp == null || randomBits == null) {
+            throw new Error('Missing argument for SimpleFlakeStruct.');
+        }
+        this.timestamp = timestamp;
+        this.randomBits = randomBits;
+    }
+}
+exports.SimpleFlakeStruct = SimpleFlakeStruct;
+/**
+ * Parses a simpleflake into its components
+ * @param flake - The simpleflake to parse
+ * @returns SimpleFlakeStruct containing timestamp and random bits
+ */
+function parseSimpleflake(flake) {
+    return new SimpleFlakeStruct(
+    // timestamp
+    (extractBits(flake, SIMPLEFLAKE_TIMESTAMP_SHIFT, SIMPLEFLAKE_TIMESTAMP_LENGTH)
+        + BigInt(SIMPLEFLAKE_EPOCH)).toString(10), 
+    // random bits
+    extractBits(flake, SIMPLEFLAKE_RANDOM_SHIFT, SIMPLEFLAKE_RANDOM_LENGTH).toString(10));
+}
+// Legacy function alias for backwards compatibility
+exports.simpleflakeStruct = SimpleFlakeStruct;
+// Default export for CommonJS compatibility
+exports.default = {
+    // Enhancements
+    SimpleFlakeStruct: SimpleFlakeStruct,
+    // original API
+    simpleflakeStruct: SimpleFlakeStruct,
+    extractBits: extractBits,
+    parseSimpleflake: parseSimpleflake,
+    binary: binary,
+    SIMPLEFLAKE_EPOCH: SIMPLEFLAKE_EPOCH,
+    simpleflake: simpleflake
+};
+//# sourceMappingURL=simpleflakes.js.map

package/dist/simpleflakes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simpleflakes.js","sourceRoot":"","sources":["../src/simpleflakes.ts"],"names":[],"mappings":"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"}

package/lib/simpleflakes.js

@@ -10,8 +10,8 @@ const SIMPLEFLAKE_TIMESTAMP_SHIFT = 23n;
 const CACHE_64_BIT_ZEROS = '0000000000000000000000000000000000000000000000000000000000000000';
 
 function simpleflake(ts = Date.now(), randomBits, epoch = SIMPLEFLAKE_EPOCH) {
-  return (BigInt(ts - epoch) << SIMPLEFLAKE_TIMESTAMP_SHIFT) +
-    BigInt(randomBits || Math.round(Math.random() * UNSIGNED_23BIT_MAX));
+  return ((BigInt(ts) - BigInt(epoch)) << SIMPLEFLAKE_TIMESTAMP_SHIFT) +
+    BigInt(randomBits ?? Math.round(Math.random() * UNSIGNED_23BIT_MAX));
 }
 
 function binary(value, padding = true) {

package/package.json

@@ -1,11 +1,30 @@
 {
   "name": "simpleflakes",
-  "version": "2.2.1",
+  "version": "3.0.0",
   "description": "Fast, and reliable, distributed 64-bit ID generation, in pure JavaScript, for Node.js.",
-  "main": "index.js",
+  "main": "dist/simpleflakes.js",
+  "types": "dist/simpleflakes.d.ts",
+  "files": [
+    "dist/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "test": "tape tests/**/*.js | faucet",
-    "benchmark": "node  benchmark/run.js"
+    "build": "tsc",
+    "build:clean": "rimraf dist",
+    "prebuild": "npm run build:clean",
+    "postbuild": "echo 'TypeScript compilation complete. Output in ./dist/'",
+    "type-check": "tsc --noEmit",
+    "test": "npm run build && tape tests/**/*.js | faucet",
+    "test:compatibility": "npm run build && node test-compatibility.js",
+    "test:ci": "npm run test:coverage && npm run test:compatibility",
+    "test:coverage": "nyc npm test",
+    "test:coverage:report": "nyc report --reporter=html && echo '\nHTML coverage report generated in ./coverage/index.html'",
+    "test:coverage:ci": "nyc npm test && cat ./coverage/lcov.info",
+    "test:coverage:clean": "rimraf coverage .nyc_output",
+    "benchmark": "npm run build && node  benchmark/run.js",
+    "clean": "npm run build:clean && npm run test:coverage:clean"
   },
   "repository": {
     "type": "git",
@@ -14,12 +33,15 @@
   "keywords": [
     "simpleflake",
     "snowflake",
+    "flake",
     "id",
+    "uuidv4",
+    "uuidv7",
+    "database",
+    "shards",
+    "bigint",
     "sql",
     "nosql",
-    "flake",
-    "bigint",
-    "shards",
     "partition"
   ],
   "author": {
@@ -32,12 +54,17 @@
     "url": "https://github.com/leodutra/simpleflakes/issues"
   },
   "homepage": "https://github.com/leodutra/simpleflakes#readme",
-  "dependencies": {
-    "bn.js": "^5.2.0"
+  "engines": {
+    "node": ">=16.0.0"
   },
   "devDependencies": {
+    "@types/node": "^24.3.1",
     "benchmark": "^2.1.4",
-    "faucet": "^0.0.1",
-    "tape": "^5.3.1"
+    "faucet": "^0.0.4",
+    "nyc": "^17.1.0",
+    "rimraf": "^6.0.1",
+    "tape": "^5.9.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
   }
 }

package/.eslintrc.js

@@ -1,20 +0,0 @@
-module.exports = {
-  env: {
-    commonjs: true,
-    es6: true,
-    node: true,
-  },
-  extends: [
-    'airbnb-base',
-  ],
-  globals: {
-    Atomics: 'readonly',
-    SharedArrayBuffer: 'readonly',
-  },
-  parserOptions: {
-    ecmaVersion: 2018,
-  },
-  rules: {
-    "comma-dangle": ["error", "never"]
-  },
-};

package/.travis.yml

@@ -1,24 +0,0 @@
-language: node_js
-node_js:
-- stable
-- '12'
-- '11'
-- '10'
-- '8'
-
-before_install:
-  - npm install -g istanbul coveralls codacy-coverage
-
-before_script:
-  - export CODACY_PROJECT_TOKEN=becf7b26a5d84fceab4c94d0bb2bf2ec
-
-script: "istanbul cover ./node_modules/tape/bin/tape --report lcovonly -- tests/**/*.js && cat ./coverage/lcov.info | coveralls && cat ./coverage/lcov.info | codacy-coverage && rm -rf ./coverage"
-
-deploy:
-  provider: npm
-  email: leodutra.br@gmail.com
-  api_key:
-    secure: HneFWS9YKoDkLyS5m2c8KMRnjGes1zIi3VnWX5rUuFVP/W+wybcLuyAtPbNzVhz7i7GbcKbIPLSP3lGaD4zBXg8Ds4WINBH09N1EKOrrtzt+A5SNaVHCm02rB8m992gNg0s19gVJD5/6MgJQ4+CJJTIKG3VNok3voZ8mwhZc5B6FKhlm4cU1VYJkm3ZiBeBUDxUlF77uaLIRlWjlibEwTf6Uz9rHhaDd0InlLoWwLOk136vU6QVDyh/84FhDUxytyLwi0WDnhlWQjFrsGB6oZA5MerG/udPMgKTG+pdhBRTt8QtkQqnDTmMPyQyBIe/TxOysGGKP3h7j/gz7yMhkDBCzI4xOcV25ch31kti9LjZPU0KQhJ0E2qjgOMxB1VrhxmzXAVuQKAgzsfeAKoz4xjM7BSBw4nmhdxZTGZWWDldKRcA4tu3EI30nhYaxxubim9CpPRAYK6G1bt3704Lx0XAMf5me7nxAxfzKgaD2CVKdOe3WNjnO7Nb9kSH2EYXP0Tsz8zFsqD4TRBoLs6GZpiD/tlNmoiPZ0/Bqaoh8NXvnjeOaVv2SZaZZ2Ndc0SrZS/8j6tHwhlddSAoi/IAWn5s72HUveGNKdDOxccEeeWm6s1cpxby0slTCjS5i7IyXcxlYV5k+iHmi0apf4dnc4faUgk6YM5aCvWT0yKSUI90=
-  on:
-    tags: true
-    repo: leodutra/simpleflakes

package/benchmark/run.js

@@ -1,59 +0,0 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-const Benchmark = require('benchmark');
-
-const suite = new Benchmark.Suite();
-const legacy = require('../lib/simpleflakes-legacy');
-const lib = require('../lib/simpleflakes');
-
-const { BigNum } = legacy;
-
-const SIMPLEFLAKE = '4242436206093260245';
-const SIMPLEFLAKE_EPOCH = 946702800000;
-const SIMPLEFLAKE_TIMESTAMP = 1452440606092;
-const SIMPLEFLAKE_RANDOMBITS = 7460309;
-
-suite.add('simpleflake()', () => {
-  lib.simpleflake();
-})
-  .add('simpleflake(parameterization)', () => {
-    lib.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS, SIMPLEFLAKE_EPOCH);
-  })
-  .add('binary()', () => {
-    lib.binary(64);
-  })
-  .add('BigInt()', () => {
-    // eslint-disable-next-line no-undef
-    BigInt('4242436206093260245');
-  })
-  .add('parseSimpleflake()', () => {
-    lib.parseSimpleflake(SIMPLEFLAKE);
-  });
-
-
-// legacy tests
-suite.add('legacy simpleflake()', () => {
-  legacy.simpleflake();
-})
-  .add('legacy simpleflake(parameterization)', () => {
-    legacy.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS, SIMPLEFLAKE_EPOCH);
-  })
-  .add('legacy binary()', () => {
-    legacy.binary(64);
-  })
-  .add('legacy new BigNum()', () => {
-    // eslint-disable-next-line no-new
-    new BigNum('4242436206093260245', 10);
-  })
-  .add('legacy parseSimpleflake()', () => {
-    legacy.parseSimpleflake(SIMPLEFLAKE);
-  })
-
-// add listeners
-  .on('cycle', (event) => {
-    console.log(String(event.target));
-  })
-// .on('complete', function() {
-//   console.log('Fastest is ' + this.filter('fastest').map('name'))
-// })
-// run async
-  .run({ async: true });

package/index.js

@@ -1,3 +0,0 @@
-module.exports = typeof BigInt === 'function'
-  ? require('./lib/simpleflakes')
-  : require('./lib/simpleflakes-legacy');

package/lib/simpleflakes-legacy.js

@@ -1,70 +0,0 @@
-const BigNum = require('bn.js');
-
-const SIMPLEFLAKE_EPOCH = 946684800000; // Date.UTC(2000, 0, 1) == epoch ms, since 1 Jan 2000 00:00
-const SIMPLEFLAKE_EPOCH_BIGNUM = new BigNum(SIMPLEFLAKE_EPOCH, 10);
-const UNSIGNED_23BIT_MAX = 8388607; // (Math.pow(2, 23) - 1) >> 0
-
-const SIMPLEFLAKE_TIMESTAMP_LENGTH = 41;
-const SIMPLEFLAKE_RANDOM_LENGTH = 23;
-
-const SIMPLEFLAKE_RANDOM_SHIFT = 0;
-const SIMPLEFLAKE_TIMESTAMP_SHIFT = 23;
-
-const CACHE_64_BIT_ZEROS = '0000000000000000000000000000000000000000000000000000000000000000';
-const CACHE_64_BIT_ONES = '1111111111111111111111111111111111111111111111111111111111111111';
-
-// cache
-const dateNow = Date.now || function now() { return new Date().getTime(); };
-
-function simpleflake(ts, randomBits, epoch) {
-  return new BigNum((ts || dateNow()) - (epoch == null ? SIMPLEFLAKE_EPOCH : epoch), 10)
-    .shln(23).add(new BigNum(randomBits || Math.round(Math.random() * UNSIGNED_23BIT_MAX), 10));
-}
-
-function binary(value, padding) {
-  const bignum = new BigNum(value, 10).toString(2);
-  return padding !== false && bignum.length < 64
-    ? CACHE_64_BIT_ZEROS.substr(0, 64 - bignum.length) + bignum
-    : bignum;
-}
-
-function extractBits(data, shift, length) {
-  // return new BigNum(CACHE_64_BIT_ONES.substr(0, length), 2)
-  //   .shln(shift).and(new BigNum(data, 10)).shrn(shift);
-  return (new BigNum(data, 10)).shrn(shift).and(new BigNum(CACHE_64_BIT_ONES.substr(0, length), 2));
-}
-
-function SimpleFlakeStruct(timestamp, randomBits) {
-  if (this instanceof SimpleFlakeStruct) {
-    if (timestamp == null || randomBits == null) {
-      throw new Error('Missing argument for SimpleFlakeStruct.');
-    }
-    this.timestamp = timestamp;
-    this.randomBits = randomBits;
-  } else {
-    return new SimpleFlakeStruct(timestamp, randomBits);
-  }
-}
-
-function parseSimpleflake(flake) {
-  return new SimpleFlakeStruct(
-    // timestamp
-    extractBits(flake, SIMPLEFLAKE_TIMESTAMP_SHIFT, SIMPLEFLAKE_TIMESTAMP_LENGTH)
-      .add(SIMPLEFLAKE_EPOCH_BIGNUM).toString(10),
-    // random bits
-    extractBits(flake, SIMPLEFLAKE_RANDOM_SHIFT, SIMPLEFLAKE_RANDOM_LENGTH).toString(10)
-  );
-}
-
-module.exports = {
-  // Enhancements
-  SimpleFlakeStruct,
-
-  // original API
-  simpleflakeStruct: SimpleFlakeStruct,
-  extractBits,
-  parseSimpleflake,
-  binary,
-  SIMPLEFLAKE_EPOCH,
-  simpleflake
-};

package/tests/simpleflakes-legacy.tests..js

@@ -1,76 +0,0 @@
-
-
-const test = require('tape');
-const BigNum = require('bn.js');
-const lib = require('../lib/simpleflakes-legacy');
-
-const SIMPLEFLAKE = '4242436206093260245';
-const SIMPLEFLAKE_EPOCH = 946702800000;
-const SIMPLEFLAKE_TIMESTAMP = 1452440606092;
-const SIMPLEFLAKE_RANDOMBITS = 7460309;
-
-const SIMPLEFLAKE_2 = '11101011100000001010010100000010000110011100011101010111010101';
-const SIMPLEFLAKE_16 = '3ae029408671d5d5';
-const SIMPLEFLAKE_36 = 'w8cq4fjf37x1';
-
-test('testing dependency bn.js', (t) => {
-  const bignum = new BigNum(SIMPLEFLAKE);
-  t.equal(bignum.toString(), SIMPLEFLAKE, 'bit number lib retrieves the right stored value?');
-  t.equal(bignum.toString(), bignum.toString(10), '<big number>.toString() aliases .toString(10)?');
-  t.equal(bignum.toString(2), SIMPLEFLAKE_2, 'big number as base 2?');
-  t.equal(bignum.toString(16), SIMPLEFLAKE_16, 'big number as base 16?');
-  t.equal(bignum.toString(36), SIMPLEFLAKE_36, 'big number as base 36?');
-  t.end();
-});
-
-test('testing legacy simpleflake()', (t) => {
-  t.assert(lib.simpleflake() instanceof BigNum, 'returning correct instance of big number lib?');
-  t.equal(lib.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS, SIMPLEFLAKE_EPOCH).toString(), '4242436206093260245', 'right timestamp, random bits and epoch parameterization?');
-  t.end();
-});
-
-test('testing legacy binary()', (t) => {
-  t.equal(lib.binary('83928382810918298'), '0000000100101010001011000110101101100100000001001000110110011010', 'valid simpleflake.binary(\'83928382810918298\') result?');
-  t.equal(lib.binary('83928382810918298', false), '100101010001011000110101101100100000001001000110110011010', 'valid simpleflake.binary(\'83928382810918298\', false) result?');
-  t.equal(lib.binary(7), '0000000000000000000000000000000000000000000000000000000000000111', 'valid simpleflake.binary(7) result?');
-  t.equal(lib.binary(7, false), '111', 'valid simpleflake.binary(7, false) result?');
-  t.equal(lib.binary(64), '0000000000000000000000000000000000000000000000000000000001000000', 'valid simpleflake.binary(64) result?');
-  t.equal(lib.binary(64, false), '1000000', 'valid simpleflake.binary(64, false) result?');
-  t.end();
-});
-
-test('testing legacy extractBits()', (t) => {
-  t.assert(lib.extractBits(7, 0, 1) instanceof BigNum, 'returns big number object');
-  t.equal(lib.extractBits(7, 0, 1).toString(), '1', 'extractBits(7, 0, 1)');
-  t.equal(lib.extractBits(7, 0, 2).toString(), '3', 'extractBits(7, 0, 2)');
-  t.equal(lib.extractBits(7, 0, 3).toString(), '7', 'extractBits(7, 0, 3)');
-  t.equal(lib.extractBits(7, 1, 2).toString(), '3', 'extractBits(7, 1, 2)');
-  t.equal(lib.extractBits(7, 2, 1).toString(), '1', 'extractBits(7, 2, 1)');
-  t.equal(lib.extractBits(7, 2, 2).toString(), '1', 'extractBits(7, 2, 2)');
-  t.end();
-});
-
-test('testing legacy SimpleFlakeStruct()', (t) => {
-  t.assert(lib.SimpleFlakeStruct(SIMPLEFLAKE_TIMESTAMP.toString(), SIMPLEFLAKE_RANDOMBITS.toString()) instanceof lib.SimpleFlakeStruct, 'returning new SimpleFlakeStruct() when calling SimpleFlakeStruct()?');
-  t.throws(() => {
-    let undef;
-    lib.SimpleFlakeStruct(undef, '1');
-  }, 'throw typeError when timestamp arg is missing');
-
-  t.throws(() => {
-    lib.SimpleFlakeStruct('1');
-  }, 'throw typeError when randomBits argument is missing');
-
-  t.throws(() => {
-    lib.SimpleFlakeStruct();
-  }, 'throw typeError when arguments are missing');
-
-  t.end();
-});
-
-test('testing legacy parseSimpleflake()', (t) => {
-  const flake = lib.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS);
-  t.equal(lib.parseSimpleflake(flake).timestamp, SIMPLEFLAKE_TIMESTAMP.toString(), 'correct timestamp parsing?');
-  t.equal(lib.parseSimpleflake(flake).randomBits, SIMPLEFLAKE_RANDOMBITS.toString(), 'correct random bits parsing?');
-  t.end();
-});

package/tests/simpleflakes.tests.js

@@ -1,65 +0,0 @@
-if (typeof BigInt === 'function') {
-  // eslint-disable-next-line global-require
-  const test = require('tape');
-  // eslint-disable-next-line global-require
-  const lib = require('../lib/simpleflakes');
-  const SIMPLEFLAKE_EPOCH = 946702800000;
-  const SIMPLEFLAKE_TIMESTAMP = 1452440606092;
-  const SIMPLEFLAKE_RANDOMBITS = 7460309;
-
-
-  test('testing simpleflake()', (t) => {
-    // eslint-disable-next-line valid-typeof
-    t.assert(typeof lib.simpleflake() === 'bigint', 'returning BigInt?');
-    t.equal(lib.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS, SIMPLEFLAKE_EPOCH).toString(), '4242436206093260245', 'right timestamp, random bits and epoch parameterization?');
-    t.end();
-  });
-
-  test('testing binary()', (t) => {
-    t.equal(lib.binary('83928382810918298'), '0000000100101010001011000110101101100100000001001000110110011010', "valid simpleflake.binary('83928382810918298') result?");
-    t.equal(lib.binary('83928382810918298', false), '100101010001011000110101101100100000001001000110110011010', "valid simpleflake.binary('83928382810918298', false) result?");
-    t.equal(lib.binary(7), '0000000000000000000000000000000000000000000000000000000000000111', 'valid simpleflake.binary(7) result?');
-    t.equal(lib.binary(7, false), '111', 'valid simpleflake.binary(7, false) result?');
-    t.equal(lib.binary(64), '0000000000000000000000000000000000000000000000000000000001000000', 'valid simpleflake.binary(64) result?');
-    t.equal(lib.binary(64, false), '1000000', 'valid simpleflake.binary(64, false) result?');
-    t.end();
-  });
-
-
-  test('testing extractBits()', (t) => {
-    // eslint-disable-next-line valid-typeof
-    t.assert(typeof lib.extractBits(7, 0, 1) === 'bigint', 'returns big int');
-    t.equal(lib.extractBits(7, 0, 1).toString(), '1', 'extractBits(7, 0, 1)');
-    t.equal(lib.extractBits(7, 0, 2).toString(), '3', 'extractBits(7, 0, 2)');
-    t.equal(lib.extractBits(7, 0, 3).toString(), '7', 'extractBits(7, 0, 3)');
-    t.equal(lib.extractBits(7, 1, 2).toString(), '3', 'extractBits(7, 1, 2)');
-    t.equal(lib.extractBits(7, 2, 1).toString(), '1', 'extractBits(7, 2, 1)');
-    t.equal(lib.extractBits(7, 2, 2).toString(), '1', 'extractBits(7, 2, 2)');
-    t.end();
-  });
-
-  test('testing SimpleFlakeStruct()', (t) => {
-    t.assert(lib.SimpleFlakeStruct(SIMPLEFLAKE_TIMESTAMP.toString(), SIMPLEFLAKE_RANDOMBITS.toString()) instanceof lib.SimpleFlakeStruct, 'returning new SimpleFlakeStruct() when calling SimpleFlakeStruct()?');
-    t.throws(() => {
-      let undef;
-      lib.SimpleFlakeStruct(undef, '1');
-    }, 'throw typeError when timestamp arg is missing');
-
-    t.throws(() => {
-      lib.SimpleFlakeStruct('1');
-    }, 'throw typeError when randomBits argument is missing');
-
-    t.throws(() => {
-      lib.SimpleFlakeStruct();
-    }, 'throw typeError when arguments are missing');
-
-    t.end();
-  });
-
-  test('testing parseSimpleflake()', (t) => {
-    const flake = lib.simpleflake(SIMPLEFLAKE_TIMESTAMP, SIMPLEFLAKE_RANDOMBITS);
-    t.equal(lib.parseSimpleflake(flake).timestamp, SIMPLEFLAKE_TIMESTAMP.toString(), 'correct timestamp parsing?');
-    t.equal(lib.parseSimpleflake(flake).randomBits, SIMPLEFLAKE_RANDOMBITS.toString(), 'correct random bits parsing?');
-    t.end();
-  });
-}