@bare-ts/lib 0.1.0 → 0.3.0

package/dist/codec/u8-clamped-array.d.ts

@@ -1,5 +1,5 @@
 import type { ByteCursor } from "../core/index.js";
-export declare function decodeU8ClampedArray(bc: ByteCursor): Uint8ClampedArray;
-export declare function encodeU8ClampedArray(bc: ByteCursor, x: Uint8ClampedArray): void;
-export declare function decodeU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray;
-export declare function encodeU8ClampedFixedArray(bc: ByteCursor, x: Uint8ClampedArray, len: number): void;
+export declare function readU8ClampedArray(bc: ByteCursor): Uint8ClampedArray;
+export declare function writeU8ClampedArray(bc: ByteCursor, x: Uint8ClampedArray): void;
+export declare function readU8ClampedFixedArray(bc: ByteCursor, len: number): Uint8ClampedArray;
+export declare function writeU8ClampedFixedArray(bc: ByteCursor, x: Uint8ClampedArray): void;

package/dist/codec/u8-clamped-array.js

@@ -0,0 +1,24 @@
+// src/codec/u8-clamped-array.ts
+import { readFixedData } from "./data.js";
+import { readUintSafe, writeUintSafe } from "./primitive.js";
+import { writeU8FixedArray } from "./u8-array.js";
+function readU8ClampedArray(bc) {
+  return readU8ClampedFixedArray(bc, readUintSafe(bc));
+}
+function writeU8ClampedArray(bc, x) {
+  writeUintSafe(bc, x.length);
+  writeU8ClampedFixedArray(bc, x);
+}
+function readU8ClampedFixedArray(bc, len) {
+  return new Uint8ClampedArray(readFixedData(bc, len));
+}
+function writeU8ClampedFixedArray(bc, x) {
+  writeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+export {
+  readU8ClampedArray,
+  readU8ClampedFixedArray,
+  writeU8ClampedArray,
+  writeU8ClampedFixedArray
+};
+//# sourceMappingURL=u8-clamped-array.js.map

package/dist/core/bare-error.js

@@ -0,0 +1,14 @@
+// src/core/bare-error.ts
+var BareError = class extends Error {
+  constructor(offset, issue, opts) {
+    super(`(byte:${offset}) ${issue}`);
+    this.name = "BareError";
+    this.issue = issue;
+    this.offset = offset;
+    this.cause = opts == null ? void 0 : opts.cause;
+  }
+};
+export {
+  BareError
+};
+//# sourceMappingURL=bare-error.js.map

package/dist/core/byte-cursor.d.ts

@@ -1,9 +1,32 @@
 import type { Config } from "./config.js";
+/**
+ * @invariant bytes.buffer === view.buffer
+ * @invariant bytes.byteOffset === view.byteOffset
+ * @invariant bytes.byteLength === view.byteLength
+ * @invariant 0 <= offset <= bytes.byteLength
+ * @invariant bytes.byteLength <= config.maxBufferLength
+ *
+ * |         {bytes,view}.buffer                      |
+ *        |          bytes                    |
+ *        |          view                     |
+ *        |<------ offset ------>|
+ *        |<----------- config.maxBufferLength ------------>|
+ */
 export declare class ByteCursor {
+    bytes: Uint8Array;
     readonly config: Config;
+    /**
+     * Read and write Offset in {@link view} and {@link bytes}
+     */
     offset: number;
     view: DataView;
-    constructor(bytes: ArrayBuffer | Uint8Array, config: Config);
+    /**
+     * @param bytes read and/or write buffer
+     * @param config runtime configuration
+     * @throw BareError when the buffer exceeds the maximum allowed length
+     *  `config.maxBufferLength`
+     */
+    constructor(bytes: Uint8Array, config: Config);
     /**
      * @param min number of needed bytes
      * @throw BareError when there is not enough bytes
@@ -11,6 +34,8 @@ export declare class ByteCursor {
     check(min: number): void;
     /**
      * @param min number of bytes to reserve
+     * @throw BareError when the buffer exceeds the maximum allowed length
+     *  `config.maxBufferLength`
      */
     reserve(min: number): void;
     /**
@@ -21,11 +46,4 @@ export declare class ByteCursor {
      * @returns read bytes
      */
     read(len: number): Uint8Array;
-    /**
-     * Write {@code bytes} in the buffer and advance cursor by
-     *  {@code bytes.length}
-     *
-     * @param bytes bytes to copy
-     */
-    write(bytes: Uint8Array): void;
 }

package/dist/core/byte-cursor.js

@@ -0,0 +1,42 @@
+// src/core/byte-cursor.ts
+import { TOO_LARGE_BUFFER } from "../util/constants.js";
+import { BareError } from "./bare-error.js";
+var ByteCursor = class {
+  constructor(bytes, config) {
+    if (bytes.length > config.maxBufferLength) {
+      throw new BareError(0, TOO_LARGE_BUFFER);
+    }
+    this.bytes = bytes;
+    this.config = config;
+    this.offset = 0;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.length);
+  }
+  check(min) {
+    if (this.offset + min > this.bytes.length) {
+      throw new BareError(this.offset, "missing bytes");
+    }
+  }
+  reserve(min) {
+    const minLen = this.offset + min | 0;
+    if (minLen > this.bytes.length) {
+      if (minLen > this.config.maxBufferLength) {
+        throw new BareError(0, TOO_LARGE_BUFFER);
+      }
+      const newLen = Math.min(minLen << 1, this.config.maxBufferLength);
+      const newBytes = new Uint8Array(newLen);
+      newBytes.set(this.bytes);
+      this.bytes = newBytes;
+      this.view = new DataView(newBytes.buffer);
+    }
+  }
+  read(len) {
+    this.check(len);
+    const offset = this.offset;
+    this.offset += len;
+    return this.bytes.subarray(offset, offset + len);
+  }
+};
+export {
+  ByteCursor
+};
+//# sourceMappingURL=byte-cursor.js.map

package/dist/core/config.d.ts

@@ -4,4 +4,9 @@ export interface Config {
     readonly textDecoderThreshold: number;
     readonly textEncoderThreshold: number;
 }
-export declare function Config(part: Partial<Config>): Config;
+export declare function Config({ initialBufferLength, maxBufferLength, textDecoderThreshold, textEncoderThreshold, }: {
+    initialBufferLength?: number | undefined;
+    maxBufferLength?: number | undefined;
+    textDecoderThreshold?: number | undefined;
+    textEncoderThreshold?: number | undefined;
+}): Config;

package/dist/core/config.js

@@ -0,0 +1,27 @@
+// src/core/config.ts
+import { assert } from "../util/assert.js";
+import { TOO_LARGE_NUMBER } from "../util/constants.js";
+import { isU32 } from "../util/validator.js";
+function Config({
+  initialBufferLength = 1024,
+  maxBufferLength = 1024 * 1024 * 32,
+  textDecoderThreshold = 256,
+  textEncoderThreshold = 256
+}) {
+  const config = {
+    initialBufferLength,
+    maxBufferLength,
+    textDecoderThreshold,
+    textEncoderThreshold
+  };
+  assert(isU32(config.initialBufferLength), TOO_LARGE_NUMBER);
+  assert(isU32(config.maxBufferLength), TOO_LARGE_NUMBER);
+  assert(isU32(config.textDecoderThreshold), TOO_LARGE_NUMBER);
+  assert(isU32(config.textEncoderThreshold), TOO_LARGE_NUMBER);
+  assert(config.initialBufferLength <= config.maxBufferLength, "initialBufferLength must be lower than or equal to maxBufferLength");
+  return config;
+}
+export {
+  Config
+};
+//# sourceMappingURL=config.js.map

package/dist/core/index.js

@@ -0,0 +1,5 @@
+// src/core/index.ts
+export * from "./bare-error.js";
+export * from "./config.js";
+export * from "./byte-cursor.js";
+//# sourceMappingURL=index.js.map