@gsknnft/bigint-buffer 1.3.2 → 1.4.2

package/src/conversion/test/bigintToText.test.ts

@@ -0,0 +1,30 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('bigintToText', () => {
+  const inputs = [
+    'Hello World', 'Apañarse por qué?',
+    `Lorem ipsum dolor sit amet, consectetur adipisci tempor incidunt ut labore et dolore magna aliqua veniam, quis nostrud exercitation ullamcorpor s commodo consequat. Duis autem vel eum irrure esse molestiae consequat, vel illum dolore eu fugi et iusto odio dignissim qui blandit praesent luptat exceptur sint occaecat cupiditat non provident, deserunt mollit anim id est laborum et dolor fuga distinct. Nam liber tempor cum soluta nobis elige quod maxim placeat facer possim omnis volupt
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i, dolore eu fugiat nulla pariatur. At vero eos et accusa praesant luptatum delenit aigue duos dolor et mole provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend optio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i dolore eu fugiat nulla pariatur. At vero eos et accus praesant luptatum delenit aigue duos dolor et mol provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend oprio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud`
+  ];
+
+  describe('bigintToText((textToBigint(str))) === str ', () => {
+    for (const input of inputs) {
+      describe(`bigintToText((textToBigint(${input})))`, () => {
+        it(`should return ${input}`, () => {
+          const ret = bc.bigintToText(bc.textToBigint(input));
+          expect(ret).to.equal(input);
+        });
+      });
+    }
+  });
+
+  describe('bigintToText(-6n)', () => {
+    it('should throw RangeError', () => {
+      expect(() => bc.bigintToText(BigInt('-6'))).to.throw(RangeError);
+    });
+  });
+});

package/src/conversion/test/bufToBigint.test.ts

@@ -0,0 +1,20 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('bufToBigint', () => {
+  const tests = [
+    {input: new Uint32Array(2), output: BigInt(0)},
+    {input: bc.hexToBuf('ffffffff'), output: BigInt('4294967295')}, {
+      input: new Uint16Array(bc.hexToBuf('ffffffff', true)),
+      output: BigInt('4294967295')
+    }
+  ];
+  for (const test of tests) {
+    describe(`bufToBigint(${String(bc.bufToHex(test.input))})`, () => {
+      it(`should return ${String(test.output.toString())}`, () => {
+        const ret = bc.bufToBigint(test.input);
+        expect(ret.toString()).to.equal(test.output.toString());
+      });
+    });
+  }
+});

package/src/conversion/test/hexToBigint.test.ts

@@ -0,0 +1,22 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('hexToBigint', () => {
+  const inputs = [
+    {bi: BigInt(1), hex: '1'}, {bi: BigInt(31), hex: '1F'}, {
+      bi: BigInt('12485413541784539569456874935679853424678352483761'),
+      hex: '88af94e6b1e99f8bf3b01edb619caaa656A5c75b1'
+    }
+  ];
+
+  describe('hexToBigint', () => {
+    for (const input of inputs) {
+      describe(`hexToBigint(${input.hex})`, () => {
+        it(`should return ${input.bi}`, () => {
+          const ret = bc.hexToBigint(input.hex);
+          expect(ret).to.equal(input.bi);
+        });
+      });
+    }
+  });
+});

package/src/conversion/test/hexToBuf.test.ts

@@ -0,0 +1,39 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('hexToBuf', () => {
+  const tests = [
+    {buf: new Uint8Array([9, 255]), hex: '09ff'},
+    {buf: new Uint16Array([5, 256]), hex: '05000001'},
+    {buf: new ArrayBuffer(2), hex: '000'},
+    {buf: new Uint8Array([1, 1]), hex: '0x101'},
+    {buf: new Uint8Array([1, 1, 1]), hex: '10101'}
+  ];
+
+  describe('hexToBuf and bufToHex', () => {
+    for (const test of tests) {
+      describe(`bufToHex([${(new Uint8Array(test.buf)).toString()}])`, () => {
+        const byteLength = test.buf.byteLength;
+        const expected = bc.parseHex(test.hex, false, byteLength);
+        it(`should return ${String(expected)}`, () => {
+          const ret = bc.bufToHex(test.buf);
+          expect(ret).to.equal(expected);
+        });
+      });
+      describe(`bufToHex(hexToBuf(${test.hex}))`, () => {
+        const byteLength = test.buf.byteLength;
+        const expected = bc.parseHex(test.hex, false, byteLength);
+        it(`should return ${String(expected)}`, () => {
+          const buf = bc.hexToBuf(test.hex);
+          const ret = bc.bufToHex(buf);
+          expect(ret).to.equal(expected);
+        });
+      });
+      describe('hexToBuf(\'12412fgt3\')', () => {
+        it('should throw RangeError', () => {
+          expect(() => bc.hexToBuf('12412fgt3')).to.throw(RangeError);
+        });
+      });
+    }
+  });
+});

package/src/conversion/test/parseHex.test.ts

@@ -0,0 +1,35 @@
+import * as bc from '#pkg';
+import {describe, expect, it} from 'vitest';
+
+describe('parseHex', () => {
+  const vectors = [
+    {input: '0x234FE678', output: '234FE678'},
+    {input: '234FE687', output: '234FE687'},
+    {input: '0x123546146f23A2', output: '123546146f23A2'}
+  ];
+  for (const vector of vectors) {
+    it(`parseHex('${vector.input}') should return '${vector.output}'`, () => {
+      const ret = bc.parseHex(vector.input);
+      expect(ret).to.equal(vector.output);
+    });
+    it(`parseHex('${vector.input}', true) should return '0x${vector.output}'`,
+       () => {
+         const ret = bc.parseHex(vector.input, true);
+         expect(ret).to.equal('0x' + vector.output);
+       });
+  }
+  it('parseHex(\'adge3\') should throw error', () => {
+    expect(() => {
+      bc.parseHex('adge3');
+    }).to.throw(RangeError);
+  });
+  it('parseHex(\'1287a3\', undefined, 4) should return \'001287a3\'', () => {
+    const ret = bc.parseHex('1287a3', undefined, 4);
+    expect(ret).to.equal('001287a3');
+  });
+  it('parseHex(\'1287542fe21\', true, 4) should throw error', () => {
+    expect(() => {
+      bc.parseHex('1287542fe21', true, 4);
+    }).to.throw(RangeError);
+  });
+});

package/src/conversion/test/setup.test.ts

@@ -0,0 +1,9 @@
+import {describe, expect, it} from 'vitest';
+
+(globalThis as {expect?: typeof expect}).expect = expect;
+
+describe('setup', () => {
+  it('noop', () => {
+    expect(true).to.equal(true);
+  });
+});

package/src/conversion/test/textToBuf.test.ts

@@ -0,0 +1,26 @@
+import * as bc from "#pkg";
+import { describe, expect, it } from "vitest";
+
+describe("textToBuf", () => {
+  const inputs = [
+    "Hello World",
+    "Apañarse por qué?",
+    `Lorem ipsum dolor sit amet, consectetur adipisci tempor incidunt ut labore et dolore magna aliqua veniam, quis nostrud exercitation ullamcorpor s commodo consequat. Duis autem vel eum irrure esse molestiae consequat, vel illum dolore eu fugi et iusto odio dignissim qui blandit praesent luptat exceptur sint occaecat cupiditat non provident, deserunt mollit anim id est laborum et dolor fuga distinct. Nam liber tempor cum soluta nobis elige quod maxim placeat facer possim omnis volupt
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i, dolore eu fugiat nulla pariatur. At vero eos et accusa praesant luptatum delenit aigue duos dolor et mole provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend optio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud
+  
+  Lorem ipsum dolor si amet, consectetur adipiscing incidunt ut labore et dolore magna aliquam erat nostrud exercitation ullamcorper suscipit laboris nis duis autem vel eum irure dolor in reprehenderit i dolore eu fugiat nulla pariatur. At vero eos et accus praesant luptatum delenit aigue duos dolor et mol provident, simil tempor sunt in culpa qui officia de fuga. Et harumd dereud facilis est er expedit disti eligend oprio congue nihil impedit doming id quod assumenda est, omnis dolor repellend. Temporibud`,
+  ];
+
+  let returnArrayBuffer = false;
+
+  for (const input of inputs) {
+    describe(`bufToText(textToBuf(${input.substring(0, 8)}...))`, () => {
+      it(`should return ${input.substring(0, 8)}...`, () => {
+        returnArrayBuffer = returnArrayBuffer ? false : true;
+        const ret = bc.bufToText(bc.textToBuf(input, returnArrayBuffer));
+        expect(ret).to.equal(input);
+      });
+    });
+  }
+});

package/src/conversion/tsconfig.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "rootDir": ".",
+    "target": "ESNext",                       /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', 'ES2023', 'ES2023' or 'ESNEXT'. */
+    "module": "NodeNext",
+    // "lib": [ "es2020" ],                   /* Specify library files to be included in the compilation. */
+    "allowJs": true,                          /* Allow javascript files to be compiled. */
+    "checkJs": true,                          /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'react', 'react-jsx', 'react-jsxdev', 'preserve' or 'react-native'. */
+    "strict": true,   
+    "declaration": true,
+    "removeComments": true,
+    "typeRoots": ["../types", "../../node_modules/@types", "node_modules/@types"],    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,      /* Include 'undefined' in index signature results */
+    "tsBuildInfoFile": "build/main.tsbuildinfo",
+    "lib": [ "esnext", "dom" ],
+    "types": ["node"],
+
+    /* Module Resolution Options */
+    "moduleResolution": "NodeNext",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+     "baseUrl": ".",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDir": ".",
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [ "node_modules/@types", "build/typings" ],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,               /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+    /* Advanced Options */
+    "skipLibCheck": true,                     /* Skip type checking of declaration files. */
+    "forceConsistentCasingInFileNames": true,  /* Disallow inconsistently-cased references to the same file. */
+    "resolveJsonModule": true,
+    "paths": {
+      "#pkg": ["./src/ts/index.ts"]
+    }
+  },
+"exclude": [
+  "node_modules",
+  "build",
+  "src/conversion/.dst"
+],
+"include": [
+  "src/**/*.ts",
+  "test/**/*.ts"
+]
+}

package/src/conversion/tsconfig.rollup.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "outDir": "./.rollup-tmp",
+    "composite": false
+  },
+  "include": ["src/ts/**/*"]
+}

package/src/conversion/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "readme": "none",
+  "excludePrivate": true,
+  "plugin": ["typedoc-plugin-markdown"]
+}

package/src/conversion/types/bindings.d.t.s

@@ -0,0 +1,4 @@
+declare module 'bindings' {
+  function bindings(name: string): any;
+  export = bindings;
+}

package/src/conversion/vite.config.ts

@@ -0,0 +1,10 @@
+import path from "path";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "#pkg": path.resolve(__dirname, "src/ts/index.ts"),
+    },
+  },
+});

package/src/conversion/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["src/conversion/test/**/*.test.ts"],
+  },
+  resolve: {
+    alias: {
+      "#pkg": path.resolve(__dirname, "src/ts/index.ts"),
+    },
+  },
+});

package/src/index.bench.ts

@@ -1,10 +1,9 @@
 
-import * as benchmark from 'benchmark';
+import benchmark from 'benchmark';
+import BN from 'bn.js';
 
 import {toBigIntBE, toBigIntLE, toBufferBE, toBufferLE} from './index';
 
-const BN = require('bn.js');
-
 
 // This file contains the benchmark test suite. It includes the benchmark and
 // some lightweight boilerplate code for running benchmark.js. To
@@ -106,7 +105,7 @@ suite.add('BE bigint to hex string to buffer (small)', () => {
 
 const bnSmallValue = new BN('12345678', 10);
 suite.add('BN to buffer (small)', () => {
-  return bnSmallValue.toBuffer(8);
+  return bnSmallValue.toArrayLike(Buffer, 'be', 8);
 });
 
 suite.add('LE bigint-buffer to buffer (small)', () => {
@@ -133,7 +132,7 @@ const bnLargeValue = new BN(
     'badc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00dbadc0ffee0ddf00d',
     16);
 suite.add('BN to buffer (large)', () => {
-  return bnLargeValue.toBuffer(24);
+  return bnLargeValue.toArrayLike(Buffer, 'be', 24);
 });
 
 suite.add('LE bigint-buffer to buffer (large)', () => {
@@ -204,4 +203,4 @@ suite.on('cycle', (event: benchmark.Event) => {
 });
 
 // Runs the test suite
-suite.run();
+suite.run();