@bare-ts/lib 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## Unreleased
+
+## 0.1.1 (2022-01-09)
+
+* Fix write offset when byteOffset > 0
+
+    A ByteCursor may be instantiated with an array of bytes such that
+    the array's byteOffset is greater than 0.
+    The previous ByteCursor.write implementation did not take care of adding this byteOffset to the    ByteCursor's offset.
+
+    The following code no longer fail:
+
+    ```js
+    const bytes = Uint8Array.of(42, 24).subarray(1)
+    assert(bytes.byteOffset === 1)
+
+    const bc = ByteCursor(bytes, ...)
+    bc.write(Uint8Array.of(24))
+    assert.deepEqual(Array.from(bytes), [42, 24]) // Previously failed
+    ```
+
+* Smaller CommonJS bundle
+
+* Improve byte-length computation of small string
+
 ## 0.1.0 (2022-01-02)
 
 * `ByteCursor` abstraction to read and write safely a buffer of bytes

package/README.md

@@ -1,6 +1,9 @@
 # bare-ts library
 
-![CI status][ci]
+[![CI status][ci-img]][ci-url]
+[![Coverage percentage][coveralls-img]][coveralls-url]
+[![minified and gzipped size][bundlephobia-img]][bundlephobia-url]
+[![NPM version][npm-img]][npm-url]
 
 [BARE][bare] (Binary Application Record Encoding) is a schema-based binary format that favors compactness and simplicity.
 [bare-ts/lib](#) provides decoders and encoders for basic BARE types.
@@ -12,4 +15,11 @@ The specification is likely to evolve before its final release. [bare-ts](#) imp
 
 [bare]: https://baremessages.org
 [bare-ts-tools]: https://github.com/bare-ts/tools
-[ci]: https://github.com/bare-ts/lib/actions/workflows/ci.yml/badge.svg
+[ci-img]: https://img.shields.io/github/workflow/status/bare-ts/lib/CI?label=CI&style=flat-square
+[ci-url]: https://github.com/bare-ts/lib/actions/workflows/ci.yml
+[npm-img]: https://img.shields.io/npm/v/@bare-ts/lib.svg?style=flat-square
+[npm-url]: https://www.npmjs.com/package/@bare-ts/lib
+[coveralls-img]: https://img.shields.io/coveralls/github/bare-ts/lib?style=flat-square
+[coveralls-url]: https://coveralls.io/github/bare-ts/lib?branch=main
+[bundlephobia-img]: https://img.shields.io/bundlephobia/minzip/@bare-ts/lib?label=minzipped&style=flat-square
+[bundlephobia-url]: https://bundlephobia.com/package/@bare-ts/lib

package/dist/codec/data.js

@@ -0,0 +1,26 @@
+// src/codec/data.ts
+import {
+  decodeU8Array,
+  decodeU8FixedArray,
+  encodeU8Array,
+  encodeU8FixedArray
+} from "./u8-array.js";
+function decodeData(bc) {
+  return decodeU8Array(bc).buffer;
+}
+function encodeData(bc, x) {
+  encodeU8Array(bc, new Uint8Array(x));
+}
+function decodeFixedData(bc, len) {
+  return decodeU8FixedArray(bc, len).buffer;
+}
+function encodeFixedData(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x), len);
+}
+export {
+  decodeData,
+  decodeFixedData,
+  encodeData,
+  encodeFixedData
+};
+//# sourceMappingURL=data.js.map

package/dist/codec/float-array.js

@@ -0,0 +1,99 @@
+// src/codec/float-array.ts
+import { ok as assert } from "assert";
+import { BareError } from "../core/index.js";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeF32,
+  decodeF64,
+  decodeUintSafe,
+  encodeF32,
+  encodeF64,
+  encodeUintSafe
+} from "./primitive.js";
+var NAN_NOT_ALLOWED = "NaN is not allowed";
+var decodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF32FixedArrayLE : decodeF32FixedArrayBE;
+function decodeF32FixedArrayLE(bc, len) {
+  const byteLen = len * 4;
+  const result = new Float32Array(decodeFixedData(bc, byteLen));
+  if (result.some(Number.isNaN)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  return result;
+}
+function decodeF32FixedArrayBE(bc, len) {
+  bc.check(len * 4);
+  const result = new Float32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeF32(bc);
+  return result;
+}
+var encodeF32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF32FixedArrayLE : encodeF32FixedArrayBE;
+function encodeF32FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeF32FixedArrayBE(bc, val, len) {
+  assert(val.length === len);
+  bc.reserve(val.length * 4);
+  for (let i = 0; i < val.length; i++)
+    encodeF32(bc, val[i]);
+}
+function decodeF32Array(bc) {
+  return decodeF32FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeF32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeF32FixedArray(bc, x, x.length);
+  }
+}
+var decodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeF64FixedArrayLE : decodeF64FixedArrayBE;
+function decodeF64FixedArrayLE(bc, len) {
+  const byteLen = len * 8;
+  const result = new Float64Array(decodeFixedData(bc, byteLen));
+  if (result.some(Number.isNaN)) {
+    throw new BareError(bc.offset, NAN_NOT_ALLOWED);
+  }
+  return result;
+}
+function decodeF64FixedArrayBE(bc, len) {
+  bc.check(len * 8);
+  const result = new Float64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeF64(bc);
+  return result;
+}
+var encodeF64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeF64FixedArrayLE : encodeF64FixedArrayBE;
+function encodeF64FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  assert(!x.every(Number.isNaN), NAN_NOT_ALLOWED);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeF64FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * 8);
+  for (let i = 0; i < x.length; i++)
+    encodeF64(bc, x[i]);
+}
+function decodeF64Array(bc) {
+  return decodeF64FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeF64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeF64FixedArray(bc, x, x.length);
+  }
+}
+export {
+  decodeF32Array,
+  decodeF32FixedArray,
+  decodeF64Array,
+  decodeF64FixedArray,
+  encodeF32Array,
+  encodeF32FixedArray,
+  encodeF64Array,
+  encodeF64FixedArray
+};
+//# sourceMappingURL=float-array.js.map

package/dist/codec/i16-array.js

@@ -0,0 +1,50 @@
+// src/codec/i16-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeI16,
+  decodeUintSafe,
+  encodeI16,
+  encodeUintSafe
+} from "./primitive.js";
+var I16_BYTE_COUNT = 2;
+var decodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI16FixedArrayLE : decodeI16FixedArrayBE;
+function decodeI16Array(bc) {
+  return decodeI16FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI16FixedArrayLE(bc, len) {
+  const byteCount = len * I16_BYTE_COUNT;
+  return new Int16Array(decodeFixedData(bc, byteCount));
+}
+function decodeI16FixedArrayBE(bc, len) {
+  bc.check(len * I16_BYTE_COUNT);
+  const result = new Int16Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI16(bc);
+  return result;
+}
+var encodeI16FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI16FixedArrayLE : encodeI16FixedArrayBE;
+function encodeI16Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI16FixedArray(bc, x, x.length);
+  }
+}
+function encodeI16FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI16FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * I16_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI16(bc, x[i]);
+}
+export {
+  decodeI16Array,
+  decodeI16FixedArray,
+  encodeI16Array,
+  encodeI16FixedArray
+};
+//# sourceMappingURL=i16-array.js.map

package/dist/codec/i32-array.js

@@ -0,0 +1,50 @@
+// src/codec/i32-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeI32,
+  decodeUintSafe,
+  encodeI32,
+  encodeUintSafe
+} from "./primitive.js";
+var I32_BYTE_COUNT = 4;
+var decodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI32FixedArrayLE : decodeI32FixedArrayBE;
+function decodeI32Array(bc) {
+  return decodeI32FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI32FixedArrayLE(bc, len) {
+  const byteCount = len * I32_BYTE_COUNT;
+  return new Int32Array(decodeFixedData(bc, byteCount));
+}
+function decodeI32FixedArrayBE(bc, len) {
+  bc.check(len * I32_BYTE_COUNT);
+  const result = new Int32Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI32(bc);
+  return result;
+}
+var encodeI32FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI32FixedArrayLE : encodeI32FixedArrayBE;
+function encodeI32Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI32FixedArray(bc, x, x.length);
+  }
+}
+function encodeI32FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI32FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * I32_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI32(bc, x[i]);
+}
+export {
+  decodeI32Array,
+  decodeI32FixedArray,
+  encodeI32Array,
+  encodeI32FixedArray
+};
+//# sourceMappingURL=i32-array.js.map

package/dist/codec/i64-array.js

@@ -0,0 +1,50 @@
+// src/codec/i64-array.ts
+import { ok as assert } from "assert";
+import { IS_LITTLE_ENDIAN_PLATFORM } from "../util/util.js";
+import { decodeFixedData } from "./data.js";
+import {
+  decodeI64,
+  decodeUintSafe,
+  encodeI64,
+  encodeUintSafe
+} from "./primitive.js";
+var I64_BYTE_COUNT = 8;
+var decodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? decodeI64FixedArrayLE : decodeI64FixedArrayBE;
+function decodeI64Array(bc) {
+  return decodeI64FixedArray(bc, decodeUintSafe(bc));
+}
+function decodeI64FixedArrayLE(bc, len) {
+  const byteCount = len * I64_BYTE_COUNT;
+  return new BigInt64Array(decodeFixedData(bc, byteCount));
+}
+function decodeI64FixedArrayBE(bc, len) {
+  bc.check(len * I64_BYTE_COUNT);
+  const result = new BigInt64Array(len);
+  for (let i = 0; i < len; i++)
+    result[i] = decodeI64(bc);
+  return result;
+}
+var encodeI64FixedArray = IS_LITTLE_ENDIAN_PLATFORM ? encodeI64FixedArrayLE : encodeI64FixedArrayBE;
+function encodeI64Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  if (x.length !== 0) {
+    encodeI64FixedArray(bc, x, x.length);
+  }
+}
+function encodeI64FixedArrayLE(bc, x, len) {
+  assert(x.length === len);
+  bc.write(new Uint8Array(x.buffer, x.byteOffset, x.byteLength));
+}
+function encodeI64FixedArrayBE(bc, x, len) {
+  assert(x.length === len);
+  bc.reserve(x.length * I64_BYTE_COUNT);
+  for (let i = 0; i < x.length; i++)
+    encodeI64(bc, x[i]);
+}
+export {
+  decodeI64Array,
+  decodeI64FixedArray,
+  encodeI64Array,
+  encodeI64FixedArray
+};
+//# sourceMappingURL=i64-array.js.map

package/dist/codec/i8-array.js

@@ -0,0 +1,24 @@
+// src/codec/i8-array.ts
+import { decodeFixedData } from "./data.js";
+import { decodeUintSafe, encodeUintSafe } from "./primitive.js";
+import { encodeU8FixedArray } from "./u8-array.js";
+function decodeI8Array(bc) {
+  return decodeI8FixedArray(bc, decodeUintSafe(bc));
+}
+function encodeI8Array(bc, x) {
+  encodeUintSafe(bc, x.length);
+  encodeI8FixedArray(bc, x, x.length);
+}
+function decodeI8FixedArray(bc, len) {
+  return new Int8Array(decodeFixedData(bc, len));
+}
+function encodeI8FixedArray(bc, x, len) {
+  encodeU8FixedArray(bc, new Uint8Array(x.buffer, x.byteOffset, x.byteLength), len);
+}
+export {
+  decodeI8Array,
+  decodeI8FixedArray,
+  encodeI8Array,
+  encodeI8FixedArray
+};
+//# sourceMappingURL=i8-array.js.map

package/dist/codec/index.js

@@ -0,0 +1,15 @@
+// src/codec/index.ts
+export * from "./data.js";
+export * from "./float-array.js";
+export * from "./i16-array.js";
+export * from "./i32-array.js";
+export * from "./i64-array.js";
+export * from "./i8-array.js";
+export * from "./primitive.js";
+export * from "./string.js";
+export * from "./u16-array.js";
+export * from "./u32-array.js";
+export * from "./u64-array.js";
+export * from "./u8-array.js";
+export * from "./u8-clamped-array.js";
+//# sourceMappingURL=index.js.map