@bare-ts/lib 0.4.1 → 0.6.0

package/dist/util/assert.js

@@ -1,18 +1,29 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
 export { DEV } from "#dev";
-export class AssertionError extends Error {
-  constructor() {
-    super(...arguments);
-    this.name = "AssertionError";
-  }
-}
 const V8Error = Error;
+/**
+ * @throws {AssertionError} if `test` is `false`.
+ *  The message of the error is set to `message`.
+ */
 export function assert(test, message = "") {
-  if (!test) {
-    const e = new AssertionError(message);
-    if (V8Error.captureStackTrace) {
-      V8Error.captureStackTrace(e, assert);
+    if (!test) {
+        const e = new AssertionError(message);
+        V8Error.captureStackTrace?.(e, assert);
+        throw e;
+    }
+}
+/**
+ * Indicates the failure of an assertion.
+ * This error is thrown by {@link assert }.
+ *
+ * This error should not be caught.
+ *
+ * @sealed
+ */
+export class AssertionError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "AssertionError";
     }
-    throw e;
-  }
 }

package/dist/util/constants.js

@@ -1,4 +1,7 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+// To make constants inlinable by bundlers like esbuild, we group them in this module.
+// The module must be without any imports.
 export const TEXT_DECODER_THRESHOLD = 256;
 export const TEXT_ENCODER_THRESHOLD = 256;
 export const INT_SAFE_MAX_BYTE_COUNT = 8;
@@ -8,4 +11,5 @@ export const INVALID_UTF8_STRING = "invalid UTF-8 string";
 export const NON_CANONICAL_REPRESENTATION = "must be canonical";
 export const TOO_LARGE_BUFFER = "too large buffer";
 export const TOO_LARGE_NUMBER = "too large number";
-export const IS_LITTLE_ENDIAN_PLATFORM = /* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;
+export const IS_LITTLE_ENDIAN_PLATFORM = 
+/* @__PURE__ */ new DataView(Uint16Array.of(1).buffer).getUint8(0) === 1;

package/dist/util/validator.d.ts

@@ -1,9 +1,36 @@
+/**
+ * Can `val` be stored as a signed integer in 8 bits?
+ */
 export declare function isI8(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 16 bits?
+ */
 export declare function isI16(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 32 bits?
+ */
 export declare function isI32(val: number): boolean;
+/**
+ * Can `val` be stored as a signed integer in 64 bits?
+ */
 export declare function isI64(val: bigint): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 8 bits?
+ */
 export declare function isU8(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 16 bits?
+ */
 export declare function isU16(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 32 bits?
+ */
 export declare function isU32(val: number): boolean;
+/**
+ * Can `val` be stored as an unsigned integer in 64 bits?
+ */
 export declare function isU64(val: bigint): boolean;
+/**
+ * Is `val` an unsigned integer that can be safely represented as a float?
+ */
 export declare function isU64Safe(val: number): boolean;

package/dist/util/validator.js

@@ -1,28 +1,56 @@
-"use strict";
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+/**
+ * Can `val` be stored as a signed integer in 8 bits?
+ */
 export function isI8(val) {
-  return val === val << 24 >> 24;
+    return val === (val << 24) >> 24;
 }
+/**
+ * Can `val` be stored as a signed integer in 16 bits?
+ */
 export function isI16(val) {
-  return val === val << 16 >> 16;
+    return val === (val << 16) >> 16;
 }
+/**
+ * Can `val` be stored as a signed integer in 32 bits?
+ */
 export function isI32(val) {
-  return val === (val | 0);
+    return val === (val | 0);
 }
+/**
+ * Can `val` be stored as a signed integer in 64 bits?
+ */
 export function isI64(val) {
-  return val === BigInt.asIntN(64, val);
+    return val === BigInt.asIntN(64, val);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 8 bits?
+ */
 export function isU8(val) {
-  return val === (val & 255);
+    return val === (val & 0xff);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 16 bits?
+ */
 export function isU16(val) {
-  return val === (val & 65535);
+    return val === (val & 0xffff);
 }
+/**
+ * Can `val` be stored as an unsigned integer in 32 bits?
+ */
 export function isU32(val) {
-  return val === val >>> 0;
+    return val === val >>> 0;
 }
+/**
+ * Can `val` be stored as an unsigned integer in 64 bits?
+ */
 export function isU64(val) {
-  return val === BigInt.asUintN(64, val);
+    return val === BigInt.asUintN(64, val);
 }
+/**
+ * Is `val` an unsigned integer that can be safely represented as a float?
+ */
 export function isU64Safe(val) {
-  return Number.isSafeInteger(val) && val >= 0;
+    return Number.isSafeInteger(val) && val >= 0;
 }

package/imports/dev.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV = false

package/imports/dev.development.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV = true

package/imports/dev.development.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = true

package/imports/dev.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = false

package/imports/dev.node.d.ts

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export declare const DEV: boolean

package/imports/dev.node.js

@@ -0,0 +1,4 @@
+//! Copyright (c) 2022 Victorien Elvinger
+//! Licensed under the MIT License (https://mit-license.org/)
+
+export const DEV = process.env.NODE_ENV === "development"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bare-ts/lib",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "TypeScript library for BARE, a compact and simple binary-serialization format",
   "keywords": [
     "bare",
@@ -24,25 +24,24 @@
     "node": "^14.18.0 || >=16.0.0"
   },
   "type": "module",
-  "module": "./dist/index.js",
-  "main": "./dist/index.cjs",
   "exports": {
     "./package.json": "./package.json",
     ".": {
+      "module": "./dist/index.js",
+      "module-sync": "./dist/index.js",
       "require": {
         "types": "./dist/index.d.cts",
         "default": "./dist/index.cjs"
       },
       "types": "./dist/index.d.ts",
-      "module": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "imports": {
     "#dev": {
-      "development": "./dist/env/dev.development.js",
-      "node": "./dist/env/dev.node.js",
-      "default": "./dist/env/dev.js"
+      "development": "./imports/dev.development.js",
+      "node": "./imports/dev.node.js",
+      "default": "./imports/dev.js"
     }
   },
   "sideEffects": false,
@@ -50,26 +49,28 @@
     "dist/**/*.cjs",
     "dist/**/*.d.cts",
     "dist/**/*.d.ts",
-    "dist/**/*.js"
+    "dist/**/*.js",
+    "imports/**/*.d.ts",
+    "imports/**/*.js"
   ],
-  "directories": {
-    "test": "tests"
-  },
   "scripts": {
-    "build": "sh ./scripts/build.sh",
+    "build": "npm run build:esm && npm run build:d.cts && npm run build:cjs",
+    "build:d.cts": "cp -f dist/index.d.ts dist/index.d.cts",
+    "build:cjs": "esbuild src/index.ts --bundle --target=es2020 --platform=node > dist/index.cjs",
+    "build:esm": "tsc --build src/",
+    "check": "tsc --build src src/tsconfig-test.json && biome ci --error-on-warnings .",
     "clean": "rm -rf dist coverage",
     "coverage": "c8 --reporter=lcovonly npm test",
-    "format": "rome format --write .",
-    "prepare": "validate-commit-msg",
-    "prepublishOnly": "npm run clean && npm test",
-    "test": "sh ./scripts/test.sh",
+    "format": "biome check --linter-enabled=false --write .",
+    "lint": "biome lint --error-on-warnings .",
+    "prepublishOnly": "npm run clean && npm run build && npm test",
+    "test": "NODE_ENV=development node --test && npm run check",
     "version": "sh ./scripts/version.sh"
   },
   "devDependencies": {
-    "esbuild": "0.18.4",
-    "oletus": "4.0.0",
-    "rome": "12.1.3",
-    "typescript": "5.1.3",
-    "validate-commit-message": "3.2.0"
+    "@biomejs/biome": "2.3.4",
+    "@types/node": "20.19.21",
+    "esbuild": "0.27.0",
+    "typescript": "5.9.3"
   }
 }

package/dist/codec/float-array.d.ts

@@ -1,14 +0,0 @@
-import { type ByteCursor } from "../core/byte-cursor.js";
-export declare const readF32FixedArray: typeof readF32FixedArrayLe;
-declare function readF32FixedArrayLe(bc: ByteCursor, len: number): Float32Array;
-export declare const writeF32FixedArray: typeof writeF32FixedArrayLe;
-declare function writeF32FixedArrayLe(bc: ByteCursor, x: Float32Array): void;
-export declare function readF32Array(bc: ByteCursor): Float32Array;
-export declare function writeF32Array(bc: ByteCursor, x: Float32Array): void;
-export declare const readF64FixedArray: typeof readF64FixedArrayLe;
-declare function readF64FixedArrayLe(bc: ByteCursor, len: number): Float64Array;
-export declare const writeF64FixedArray: typeof writeF64FixedArrayLe;
-declare function writeF64FixedArrayLe(bc: ByteCursor, x: Float64Array): void;
-export declare function readF64Array(bc: ByteCursor): Float64Array;
-export declare function writeF64Array(bc: ByteCursor, x: Float64Array): void;
-export {};

package/dist/codec/float-array.js

@@ -1,93 +0,0 @@
-"use strict";
-import { check, reserve } from "../core/byte-cursor.js";
-import { DEV, assert } from "../util/assert.js";
-import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/constants.js";
-import { isU32 } from "../util/validator.js";
-import { readFixedData } from "./data.js";
-import {
-  readF32,
-  readF64,
-  readUintSafe32,
-  writeF32,
-  writeF64,
-  writeUintSafe32
-} from "./primitive.js";
-import { writeU8FixedArray } from "./u8-array.js";
-export const readF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF32FixedArrayLe : readF32FixedArrayBe;
-function readF32FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteLen = len * 4;
-  const result = new Float32Array(readFixedData(bc, byteLen));
-  return result;
-}
-function readF32FixedArrayBe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  check(bc, len * 4);
-  const result = new Float32Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = readF32(bc);
-  }
-  return result;
-}
-export const writeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF32FixedArrayLe : writeF32FixedArrayBe;
-function writeF32FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function writeF32FixedArrayBe(bc, val) {
-  reserve(bc, val.length * 4);
-  for (let i = 0; i < val.length; i++) {
-    writeF32(bc, val[i]);
-  }
-}
-export function readF32Array(bc) {
-  return readF32FixedArray(bc, readUintSafe32(bc));
-}
-export function writeF32Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  if (x.length !== 0) {
-    writeF32FixedArray(bc, x);
-  }
-}
-export const readF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? readF64FixedArrayLe : readF64FixedArrayBe;
-function readF64FixedArrayLe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  const byteLen = len * 8;
-  const result = new Float64Array(readFixedData(bc, byteLen));
-  return result;
-}
-function readF64FixedArrayBe(bc, len) {
-  if (DEV) {
-    assert(isU32(len));
-  }
-  check(bc, len * 8);
-  const result = new Float64Array(len);
-  for (let i = 0; i < len; i++) {
-    result[i] = readF64(bc);
-  }
-  return result;
-}
-export const writeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? writeF64FixedArrayLe : writeF64FixedArrayBe;
-function writeF64FixedArrayLe(bc, x) {
-  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
-}
-function writeF64FixedArrayBe(bc, x) {
-  reserve(bc, x.length * 8);
-  for (let i = 0; i < x.length; i++) {
-    writeF64(bc, x[i]);
-  }
-}
-export function readF64Array(bc) {
-  return readF64FixedArray(bc, readUintSafe32(bc));
-}
-export function writeF64Array(bc, x) {
-  writeUintSafe32(bc, x.length);
-  if (x.length !== 0) {
-    writeF64FixedArray(bc, x);
-  }
-}