@gsknnft/bigint-buffer 1.4.6 → 1.4.7

package/src/conversion/src/docs/index.md

@@ -1,52 +0,0 @@
-[![Licence: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md)
-[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
-{{GITHUB_ACTIONS_BADGES}}
-
-# {{PKG_NAME}} v1.4.5
-
-Convert to/from non-negative integers represented with [ES-2020 native JS implementation of BigInt](https://tc39.es/ecma262/#sec-bigint-objects) from/to:
-
-- `Buffer` (node.js) or `ArrayBuffer|TypedArray` (native js),
-- hex `string`,
-- utf8-encoded text `string`,
-- standard and url-safe base64 with and without padding.
-
-It provides a common interface for the conversions that works for both **node.js** and **native javascript**.
-
-**New in 1.4.5:**
-- FixedPoint utilities for high-precision math and conversions
-- Native bindings included in `build/Release/` out of the box
-- Improved JS fallback for environments without native support
-
-> Note that there is not a directly visible `TypedArray()` constructor, but a set of typed array ones: `Int8Array()`, `Uint8Array()`, `Uint8ClampedArray()`, `Int16Array()`, `Uint16Array()`, `Int32Array()`, `Uint32Array()`, `Float32Array()`, `Float64Array()`, `BigInt64Array()`, `BigUint64Array()`.
-
-## Usage
-
-`{{PKG_NAME}}` can be imported to your project with `npm`:
-
-```console
-npm install {{PKG_NAME}}
-```
-
-Then either require (Node.js CJS):
-
-```javascript
-const {{PKG_CAMELCASE}} = require('{{PKG_NAME}}')
-```
-
-or import (JavaScript ES module):
-
-```javascript
-import * as {{PKG_CAMELCASE}} from '{{PKG_NAME}}'
-```
-
-The appropriate version for browser or node is automatically exported.
-
-> BigInt is [ES-2020](https://tc39.es/ecma262/#sec-bigint-objects). In order to use it with TypeScript you should set `target` (and probably also `lib`) to at least `es2020` in `tsconfig.json`.
-
-You can also download the {{IIFE_BUNDLE}}, the {{ESM_BUNDLE}} or the {{UMD_BUNDLE}} and manually add it to your project, or, if you have already installed `{{PKG_NAME}}` in your project, just get the bundles from `node_modules/{{PKG_NAME}}/dist/bundles/`.
-
-## API reference documentation
-
-[Check the API](./docs/API.md)

package/src/conversion/src/ts/converter.ts

@@ -1,85 +0,0 @@
-import { Buffer } from 'buffer';
-import path from 'path';
-import fs from 'fs';
-
-export interface ConverterInterface {
-  toBigInt: (buf: Buffer, bigEndian?: boolean) => bigint;
-  fromBigInt: (num: bigint, buf: Buffer, bigEndian?: boolean) => Buffer;
-}
-
-export let isNative = false;
-
-let converter: ConverterInterface | undefined;
-let nativeLoadError: unknown;
-
-export const IS_BROWSER =
-  typeof globalThis !== "undefined" &&
-  typeof (globalThis as { document?: unknown }).document !== "undefined";
-
-export const candidateRoots = [
-  // when running from dist/
-  path.resolve(__dirname, "../.."),
-  // when running from build/conversion/src/ts
-  path.resolve(__dirname, "../../.."),
-  // when running from src/conversion/src/ts
-  path.resolve(__dirname, "../../../.."),
-];
-
-export const findModuleRoot = (): string => {
-  for (const root of candidateRoots) {
-    const candidate = path.join(root, "build", "Release", "bigint_buffer.node");
-    if (fs.existsSync(candidate)) return root;
-  }
-  return candidateRoots[0];
-};
-
-export function loadNative(): ConverterInterface | undefined {
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const bindings = require("bindings");
-    const moduleRoot = findModuleRoot();
-    return bindings({
-      bindings: "bigint_buffer",
-      module_root: moduleRoot,
-    }) as ConverterInterface;
-  } catch (err) {
-    nativeLoadError = err;
-    return undefined;
-  }
-}
-
-if (!IS_BROWSER) {
-  converter = loadNative();
-  isNative = converter !== undefined;
-  if (
-    !isNative &&
-    nativeLoadError !== undefined &&
-    process.env?.BIGINT_BUFFER_SILENT_NATIVE_FAIL !== "1"
-  ) {
-    console.warn(
-      "bigint-buffer: Failed to load native bindings; using pure JS fallback. Run npm run rebuild to restore native.",
-      nativeLoadError
-    );
-  }
-}
-
-if (converter === undefined) {
-  // fallback to pure JS if needed (browser or when native load fails)
-  converter = {
-    toBigInt: (buf: Buffer, bigEndian = true) => {
-      const copy = Buffer.from(buf);
-      if (!bigEndian) copy.reverse();
-      const hex = copy.toString("hex");
-      return hex.length === 0 ? 0n : BigInt(`0x${hex}`);
-    },
-    fromBigInt: (num: bigint, buf: Buffer, bigEndian = true) => {
-      const hex = num.toString(16);
-      const width = buf.length;
-      const filled = hex.padStart(width * 2, "0").slice(0, width * 2);
-      const tmp = Buffer.from(filled, "hex");
-      if (!bigEndian) tmp.reverse();
-      tmp.copy(buf);
-      return buf;
-    },
-  };
-}

package/src/conversion/src/ts/fixedPoint/index.ts

@@ -1,87 +0,0 @@
-import { bigintToHex, hexToBigint } from "../index";
-
-export type FixedPoint = string;
-
-export const FIXED_POINT_DECIMALS = 9;
-export const FIXED_POINT_PATTERN = /^-?0x[0-9a-f]+$/i;
-export const ZERO_FIXED_POINT: FixedPoint = '0x0';
-
-const normalizeHex = (value: string): string =>
-  value.startsWith('0x') || value.startsWith('0X') ? value : `0x${value}`;
-
-const toHexString = (value: bigint): FixedPoint => {
-  if (value === 0n) {
-    return ZERO_FIXED_POINT;
-  }
-  const isNegative = value < 0n;
-  const absValue = isNegative ? -value : value;
-  const hexValue = bigintToHex(absValue);
-  return `${isNegative ? '-' : ''}0x${hexValue}`;
-};
-
-export const toBigIntValue = (value?: FixedPoint): bigint => {
-  if (!value) {
-    return 0n;
-  }
-  const trimmed = value.trim();
-  if (trimmed.length === 0) {
-    return 0n;
-  }
-  const isNegative = trimmed.startsWith('-');
-  const body = isNegative ? trimmed.slice(1) : trimmed;
-  const normalized = normalizeHex(body);
-  const bigValue = hexToBigint(normalized);
-  return isNegative ? -bigValue : bigValue;
-};
-
-export function toFixedPoint(
-  value: number,
-  decimals: number = FIXED_POINT_DECIMALS,
-): FixedPoint {
-  if (!Number.isFinite(value)) {
-    return ZERO_FIXED_POINT;
-  }
-  const scale = Math.pow(10, decimals);
-  const scaled = BigInt(Math.round(value * scale));
-  return toHexString(scaled);
-}
-
-export function fromFixedPoint(
-  value?: FixedPoint,
-  decimals: number = FIXED_POINT_DECIMALS,
-): number {
-  const bigValue = toBigIntValue(value);
-  if (bigValue === 0n) {
-    return 0;
-  }
-  const scale = Math.pow(10, decimals);
-  return Number(bigValue) / scale;
-}
-
-export function addFixedPoint(a: FixedPoint, b: FixedPoint): FixedPoint {
-  return toHexString(toBigIntValue(a) + toBigIntValue(b));
-}
-
-export function subtractFixedPoint(a: FixedPoint, b: FixedPoint): FixedPoint {
-  return toHexString(toBigIntValue(a) - toBigIntValue(b));
-}
-
-export function averageFixedPoint(values: FixedPoint[]): FixedPoint {
-  if (values.length === 0) {
-    return ZERO_FIXED_POINT;
-  }
-  const sum = values.reduce((acc, value) => acc + toBigIntValue(value), 0n);
-  return toHexString(sum / BigInt(values.length));
-}
-
-export function compareFixedPoint(a: FixedPoint, b: FixedPoint): number {
-  const diff = toBigIntValue(a) - toBigIntValue(b);
-  if (diff === 0n) {
-    return 0;
-  }
-  return diff > 0n ? 1 : -1;
-}
-
-export function fixedPointToBigInt(value?: FixedPoint): bigint {
-  return toBigIntValue(value);
-}