@bcts/dcbor 1.0.0-alpha.15 → 1.0.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bcts/dcbor",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.17",
   "type": "module",
   "description": "Blockchain Commons Deterministic CBOR (dCBOR) for TypeScript",
   "license": "BSD-2-Clause-Patent",
@@ -71,15 +71,15 @@
     "@bcts/tsconfig": "^0.1.0",
     "@eslint/js": "^9.39.2",
     "@types/collections": "^5.1.5",
-    "@types/node": "^25.0.6",
-    "@typescript-eslint/eslint-plugin": "^8.52.0",
-    "@typescript-eslint/parser": "^8.52.0",
+    "@types/node": "^25.0.10",
+    "@typescript-eslint/eslint-plugin": "^8.53.1",
+    "@typescript-eslint/parser": "^8.53.1",
     "eslint": "^9.39.2",
     "ts-node": "^10.9.2",
-    "tsdown": "^0.18.4",
-    "typedoc": "^0.28.15",
+    "tsdown": "^0.20.1",
+    "typedoc": "^0.28.16",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.18"
   },
   "dependencies": {
     "byte-data": "^19.0.1",

package/src/byte-string.ts

@@ -44,7 +44,7 @@ import { CborError } from "./error";
  * ```
  */
 export class ByteString {
-  #data: Uint8Array;
+  private _data: Uint8Array;
 
   /**
    * Creates a new `ByteString` from a Uint8Array or array of bytes.
@@ -62,9 +62,9 @@ export class ByteString {
    */
   constructor(data: Uint8Array | number[]) {
     if (Array.isArray(data)) {
-      this.#data = new Uint8Array(data);
+      this._data = new Uint8Array(data);
     } else {
-      this.#data = new Uint8Array(data);
+      this._data = new Uint8Array(data);
     }
   }
 
@@ -103,7 +103,7 @@ export class ByteString {
    * ```
    */
   data(): Uint8Array {
-    return this.#data;
+    return this._data;
   }
 
   /**
@@ -121,7 +121,7 @@ export class ByteString {
    * ```
    */
   len(): number {
-    return this.#data.length;
+    return this._data.length;
   }
 
   /**
@@ -139,7 +139,7 @@ export class ByteString {
    * ```
    */
   isEmpty(): boolean {
-    return this.#data.length === 0;
+    return this._data.length === 0;
   }
 
   /**
@@ -160,10 +160,10 @@ export class ByteString {
    */
   extend(other: Uint8Array | number[]): void {
     const otherArray = Array.isArray(other) ? new Uint8Array(other) : other;
-    const newData = new Uint8Array(this.#data.length + otherArray.length);
-    newData.set(this.#data, 0);
-    newData.set(otherArray, this.#data.length);
-    this.#data = newData;
+    const newData = new Uint8Array(this._data.length + otherArray.length);
+    newData.set(this._data, 0);
+    newData.set(otherArray, this._data.length);
+    this._data = newData;
   }
 
   /**
@@ -184,7 +184,7 @@ export class ByteString {
    * ```
    */
   toUint8Array(): Uint8Array {
-    return new Uint8Array(this.#data);
+    return new Uint8Array(this._data);
   }
 
   /**
@@ -211,7 +211,7 @@ export class ByteString {
    * ```
    */
   iter(): Iterator<number> {
-    return this.#data.values();
+    return this._data.values();
   }
 
   /**
@@ -233,7 +233,7 @@ export class ByteString {
    * ```
    */
   toCbor(): Cbor {
-    return toCbor(this.#data);
+    return toCbor(this._data);
   }
 
   /**
@@ -272,7 +272,7 @@ export class ByteString {
    * @returns Byte at index or undefined
    */
   at(index: number): number | undefined {
-    return this.#data[index];
+    return this._data[index];
   }
 
   /**
@@ -282,9 +282,9 @@ export class ByteString {
    * @returns true if equal
    */
   equals(other: ByteString): boolean {
-    if (this.#data.length !== other.#data.length) return false;
-    for (let i = 0; i < this.#data.length; i++) {
-      if (this.#data[i] !== other.#data[i]) return false;
+    if (this._data.length !== other._data.length) return false;
+    for (let i = 0; i < this._data.length; i++) {
+      if (this._data[i] !== other._data[i]) return false;
     }
     return true;
   }

package/src/date.ts

@@ -67,7 +67,7 @@ import { CborError } from "./error";
  * ```
  */
 export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDecodable<CborDate> {
-  #datetime: Date;
+  private _datetime: Date;
 
   /**
    * Creates a new `CborDate` from the given JavaScript `Date`.
@@ -87,7 +87,7 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    */
   static fromDatetime(dateTime: Date): CborDate {
     const instance = new CborDate();
-    instance.#datetime = new Date(dateTime);
+    instance._datetime = new Date(dateTime);
     return instance;
   }
 
@@ -265,7 +265,7 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * ```
    */
   datetime(): Date {
-    return new Date(this.#datetime);
+    return new Date(this._datetime);
   }
 
   /**
@@ -285,8 +285,8 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * ```
    */
   timestamp(): number {
-    const wholeSecondsSinceUnixEpoch = Math.trunc(this.#datetime.getTime() / 1000);
-    const msecs = this.#datetime.getTime() % 1000;
+    const wholeSecondsSinceUnixEpoch = Math.trunc(this._datetime.getTime() / 1000);
+    const msecs = this._datetime.getTime() % 1000;
     return wholeSecondsSinceUnixEpoch + msecs / 1000.0;
   }
 
@@ -430,7 +430,7 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
     }
 
     const date = CborDate.fromTimestamp(timestamp);
-    this.#datetime = date.#datetime;
+    this._datetime = date._datetime;
     return this;
   }
 
@@ -495,7 +495,7 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * ```
    */
   toString(): string {
-    const dt = this.#datetime;
+    const dt = this._datetime;
     // Check only hours, minutes, and seconds (not milliseconds) to match Rust behavior
     const hasTime = dt.getUTCHours() !== 0 || dt.getUTCMinutes() !== 0 || dt.getUTCSeconds() !== 0;
 
@@ -521,7 +521,7 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * @returns true if dates represent the same moment in time
    */
   equals(other: CborDate): boolean {
-    return this.#datetime.getTime() === other.#datetime.getTime();
+    return this._datetime.getTime() === other._datetime.getTime();
   }
 
   /**
@@ -531,8 +531,8 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
    * @returns -1 if this < other, 0 if equal, 1 if this > other
    */
   compare(other: CborDate): number {
-    const thisTime = this.#datetime.getTime();
-    const otherTime = other.#datetime.getTime();
+    const thisTime = this._datetime.getTime();
+    const otherTime = other._datetime.getTime();
     if (thisTime < otherTime) return -1;
     if (thisTime > otherTime) return 1;
     return 0;
@@ -548,6 +548,6 @@ export class CborDate implements CborTagged, CborTaggedEncodable, CborTaggedDeco
   }
 
   private constructor() {
-    this.#datetime = new Date();
+    this._datetime = new Date();
   }
 }

package/src/map.ts

@@ -44,14 +44,14 @@ export interface MapEntry {
  * encoded CBOR representation, ensuring deterministic encoding.
  */
 export class CborMap {
-  #dict: SortedMap<MapKey, MapEntry>;
+  private _dict: SortedMap<MapKey, MapEntry>;
 
   /**
    * Creates a new, empty CBOR Map.
    * Optionally initializes from a JavaScript Map.
    */
   constructor(map?: Map<unknown, unknown>) {
-    this.#dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
+    this._dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
 
     if (map !== undefined) {
       for (const [key, value] of map.entries()) {
@@ -76,7 +76,7 @@ export class CborMap {
     const keyCbor = cbor(key);
     const valueCbor = cbor(value);
     const keyData = cborData(keyCbor);
-    this.#dict.set(keyData, { key: keyCbor, value: valueCbor });
+    this._dict.set(keyData, { key: keyCbor, value: valueCbor });
   }
 
   /**
@@ -86,7 +86,7 @@ export class CborMap {
     this.set(key, value);
   }
 
-  #makeKey<K extends CborInput>(key: K): MapKey {
+  private _makeKey<K extends CborInput>(key: K): MapKey {
     const keyCbor = cbor(key);
     return cborData(keyCbor);
   }
@@ -97,8 +97,8 @@ export class CborMap {
    * Matches Rust's Map::get().
    */
   get<K extends CborInput, V>(key: K): V | undefined {
-    const keyData = this.#makeKey(key);
-    const value = this.#dict.get(keyData);
+    const keyData = this._makeKey(key);
+    const value = this._dict.get(keyData);
     if (value === undefined) {
       return undefined;
     }
@@ -124,24 +124,24 @@ export class CborMap {
    * Matches Rust's Map::contains_key().
    */
   containsKey<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    return this.#dict.has(keyData);
+    const keyData = this._makeKey(key);
+    return this._dict.has(keyData);
   }
 
   delete<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    const existed = this.#dict.has(keyData);
-    this.#dict.delete(keyData);
+    const keyData = this._makeKey(key);
+    const existed = this._dict.has(keyData);
+    this._dict.delete(keyData);
     return existed;
   }
 
   has<K extends CborInput>(key: K): boolean {
-    const keyData = this.#makeKey(key);
-    return this.#dict.has(keyData);
+    const keyData = this._makeKey(key);
+    return this._dict.has(keyData);
   }
 
   clear(): void {
-    this.#dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
+    this._dict = new SortedMap(null, areBytesEqual, lexicographicallyCompareBytes);
   }
 
   /**
@@ -149,7 +149,7 @@ export class CborMap {
    * Matches Rust's Map::len().
    */
   get length(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -157,7 +157,7 @@ export class CborMap {
    * Also matches Rust's Map::len().
    */
   get size(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -165,7 +165,7 @@ export class CborMap {
    * Matches Rust's Map::len().
    */
   len(): number {
-    return this.#dict.length;
+    return this._dict.length;
   }
 
   /**
@@ -173,7 +173,7 @@ export class CborMap {
    * Matches Rust's Map::is_empty().
    */
   isEmpty(): boolean {
-    return this.#dict.length === 0;
+    return this._dict.length === 0;
   }
 
   /**
@@ -181,7 +181,7 @@ export class CborMap {
    * Keys are sorted in lexicographic order of their encoded CBOR bytes.
    */
   get entriesArray(): MapEntry[] {
-    return this.#dict.map((value: MapEntry, _key: MapKey) => ({
+    return this._dict.map((value: MapEntry, _key: MapKey) => ({
       key: value.key,
       value: value.value,
     }));
@@ -213,21 +213,21 @@ export class CborMap {
    * Matches Rust's Map::insert_next().
    */
   setNext<K extends CborInput, V extends CborInput>(key: K, value: V): void {
-    const lastEntry = this.#dict.max();
+    const lastEntry = this._dict.max();
     if (lastEntry === undefined) {
       this.set(key, value);
       return;
     }
     const keyCbor = cbor(key);
     const newKey = cborData(keyCbor);
-    if (this.#dict.has(newKey)) {
+    if (this._dict.has(newKey)) {
       throw new CborError({ type: "DuplicateMapKey" });
     }
-    const lastEntryKey = this.#makeKey(lastEntry.key);
+    const lastEntryKey = this._makeKey(lastEntry.key);
     if (lexicographicallyCompareBytes(newKey, lastEntryKey) <= 0) {
       throw new CborError({ type: "MisorderedMapKey" });
     }
-    this.#dict.set(newKey, { key: keyCbor, value: cbor(value) });
+    this._dict.set(newKey, { key: keyCbor, value: cbor(value) });
   }
 
   get debug(): string {

package/src/set.ts

@@ -47,10 +47,10 @@ import { CborError } from "./error";
  * ```
  */
 export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet> {
-  readonly #map: CborMap;
+  private readonly _map: CborMap;
 
   constructor() {
-    this.#map = new CborMap();
+    this._map = new CborMap();
   }
 
   // =========================================================================
@@ -127,7 +127,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
   insert(value: CborInput): void {
     const cborValue = encodeCborValue(value);
     // In a set, key and value are the same
-    this.#map.set(cborValue, cborValue);
+    this._map.set(cborValue, cborValue);
   }
 
   /**
@@ -145,7 +145,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    */
   contains(value: CborInput): boolean {
     const cborValue = encodeCborValue(value);
-    return this.#map.has(cborValue);
+    return this._map.has(cborValue);
   }
 
   /**
@@ -163,14 +163,14 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    */
   delete(value: CborInput): boolean {
     const cborValue = encodeCborValue(value);
-    return this.#map.delete(cborValue);
+    return this._map.delete(cborValue);
   }
 
   /**
    * Remove all elements from the set.
    */
   clear(): void {
-    this.#map.clear();
+    this._map.clear();
   }
 
   /**
@@ -179,7 +179,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * @returns Number of elements
    */
   get size(): number {
-    return this.#map.size;
+    return this._map.size;
   }
 
   /**
@@ -188,7 +188,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * @returns true if set has no elements
    */
   isEmpty(): boolean {
-    return this.#map.size === 0;
+    return this._map.size === 0;
   }
 
   // =========================================================================
@@ -313,7 +313,7 @@ export class CborSet implements CborTaggedEncodable, CborTaggedDecodable<CborSet
    * ```
    */
   *[Symbol.iterator](): Iterator<Cbor> {
-    for (const [_, value] of this.#map) {
+    for (const [_, value] of this._map) {
       yield value;
     }
   }

package/src/tags-store.ts

@@ -89,9 +89,9 @@ export interface TagsStoreTrait {
  * Stores tags with their names and optional summarizer functions.
  */
 export class TagsStore implements TagsStoreTrait {
-  readonly #tagsByValue = new Map<string, Tag>();
-  readonly #tagsByName = new Map<string, Tag>();
-  readonly #summarizers = new Map<string, CborSummarizer>();
+  private readonly _tagsByValue = new Map<string, Tag>();
+  private readonly _tagsByName = new Map<string, Tag>();
+  private readonly _summarizers = new Map<string, CborSummarizer>();
 
   constructor() {
     // Start with empty store, matching Rust's Default implementation
@@ -123,8 +123,8 @@ export class TagsStore implements TagsStoreTrait {
       throw new Error(`Tag ${tag.value} must have a non-empty name`);
     }
 
-    const key = this.#valueKey(tag.value);
-    const existing = this.#tagsByValue.get(key);
+    const key = this._valueKey(tag.value);
+    const existing = this._tagsByValue.get(key);
 
     // Rust: if old_name != name { panic!(...) }
     if (existing?.name !== undefined && existing.name !== name) {
@@ -133,8 +133,8 @@ export class TagsStore implements TagsStoreTrait {
       );
     }
 
-    this.#tagsByValue.set(key, tag);
-    this.#tagsByName.set(name, tag);
+    this._tagsByValue.set(key, tag);
+    this._tagsByName.set(name, tag);
   }
 
   /**
@@ -173,13 +173,13 @@ export class TagsStore implements TagsStoreTrait {
    * ```
    */
   setSummarizer(tagValue: CborNumber, summarizer: CborSummarizer): void {
-    const key = this.#valueKey(tagValue);
-    this.#summarizers.set(key, summarizer);
+    const key = this._valueKey(tagValue);
+    this._summarizers.set(key, summarizer);
   }
 
   assignedNameForTag(tag: Tag): string | undefined {
-    const key = this.#valueKey(tag.value);
-    const stored = this.#tagsByValue.get(key);
+    const key = this._valueKey(tag.value);
+    const stored = this._tagsByValue.get(key);
     return stored?.name;
   }
 
@@ -188,12 +188,12 @@ export class TagsStore implements TagsStoreTrait {
   }
 
   tagForValue(value: CborNumber): Tag | undefined {
-    const key = this.#valueKey(value);
-    return this.#tagsByValue.get(key);
+    const key = this._valueKey(value);
+    return this._tagsByValue.get(key);
   }
 
   tagForName(name: string): Tag | undefined {
-    return this.#tagsByName.get(name);
+    return this._tagsByName.get(name);
   }
 
   nameForValue(value: CborNumber): string {
@@ -202,8 +202,8 @@ export class TagsStore implements TagsStoreTrait {
   }
 
   summarizer(tag: CborNumber): CborSummarizer | undefined {
-    const key = this.#valueKey(tag);
-    return this.#summarizers.get(key);
+    const key = this._valueKey(tag);
+    return this._summarizers.get(key);
   }
 
   /**
@@ -212,7 +212,7 @@ export class TagsStore implements TagsStoreTrait {
    *
    * @private
    */
-  #valueKey(value: CborNumber): string {
+  private _valueKey(value: CborNumber): string {
     return value.toString();
   }
 }