@marcuspuchalla/nachos 0.1.0

package/dist/useCborSimpleEncoder-TVxzNJ_9.d.ts

@@ -0,0 +1,268 @@
+import { h as PlutusConstr, s as CborByteString, t as CborTextString } from './types-DvNlfbKB.js';
+
+/**
+ * CBOR Encoder Type Definitions
+ * Following RFC 8949 specification
+ */
+
+/**
+ * Encoder options for controlling behavior
+ */
+interface EncodeOptions {
+    /** Enable canonical encoding (shortest form, sorted maps) */
+    canonical?: boolean;
+    /** Allow indefinite-length encoding (false in canonical mode) */
+    allowIndefinite?: boolean;
+    /** Reject duplicate map keys */
+    rejectDuplicateKeys?: boolean;
+    /** Maximum nesting depth */
+    maxDepth?: number;
+    /** Maximum output size in bytes */
+    maxOutputSize?: number;
+}
+/**
+ * Default encode options
+ */
+declare const DEFAULT_ENCODE_OPTIONS: Required<EncodeOptions>;
+/**
+ * Result of encoding operation
+ */
+interface EncodeResult {
+    /** Encoded CBOR bytes */
+    bytes: Uint8Array;
+    /** Hex string representation */
+    hex: string;
+}
+/**
+ * Values that can be encoded to CBOR
+ *
+ * Supports both plain objects (for convenience) and Maps (for type preservation).
+ * Map<any, any> is preferred for maps with non-string keys (integers, Uint8Arrays, etc.)
+ */
+type EncodableValue = number | bigint | string | boolean | null | undefined | Uint8Array | EncodableValue[] | {
+    [key: string]: EncodableValue;
+} | Map<EncodableValue, EncodableValue> | TaggedValue;
+/**
+ * Tagged CBOR value (Major Type 6)
+ */
+interface TaggedValue {
+    tag: number;
+    value: EncodableValue;
+    plutus?: PlutusConstr;
+}
+/**
+ * Encoding context that tracks state during CBOR encoding
+ */
+interface EncodeContext {
+    /** Current nesting depth */
+    depth: number;
+    /** Bytes written so far */
+    bytesWritten: number;
+    /** Encoder options */
+    options: Required<EncodeOptions>;
+}
+
+/**
+ * Main CBOR Encoder Composable
+ * High-level API for encoding JavaScript values to CBOR
+ * Following RFC 8949 specification
+ */
+
+/**
+ * Main CBOR Encoder Composable
+ *
+ * Provides a unified interface for encoding any JavaScript value to CBOR.
+ * Automatically selects the appropriate encoder based on value type.
+ *
+ * @param options - Global encoder options
+ *
+ * @example
+ * ```ts
+ * const { encode } = useCborEncoder()
+ *
+ * // Encode various types
+ * encode(42)           // Integer
+ * encode("hello")      // Text string
+ * encode([1, 2, 3])    // Array
+ * encode({ a: 1 })     // Map
+ * encode(true)         // Boolean
+ * encode(3.14)         // Float
+ * encode(new Uint8Array([0xff]))  // Byte string
+ *
+ * // With options
+ * const { encode: encodeCanonical } = useCborEncoder({ canonical: true })
+ * encodeCanonical({ z: 1, a: 2 })  // Keys will be sorted
+ * ```
+ */
+declare function useCborEncoder(globalOptions?: Partial<EncodeOptions>): {
+    encode: (value: EncodableValue) => EncodeResult;
+    encodeToHex: (value: EncodableValue) => string;
+    encodeToBytes: (value: EncodableValue) => Uint8Array;
+    encodeSequence: (values: EncodableValue[]) => EncodeResult;
+};
+
+/**
+ * CBOR Integer Encoder Composable
+ * Handles Major Type 0 (Unsigned) and Major Type 1 (Negative)
+ * Following RFC 8949 specification
+ */
+
+/**
+ * CBOR Integer Encoder Composable
+ *
+ * Provides functions to encode integers to CBOR format:
+ * - Major Type 0: Unsigned integers (0 to 2^64-1)
+ * - Major Type 1: Negative integers (-1 to -2^64)
+ *
+ * @example
+ * ```ts
+ * const { encodeUnsignedInt, encodeNegativeInt, encodeInteger } = useCborIntegerEncoder()
+ *
+ * // Encode unsigned integer
+ * const result1 = encodeUnsignedInt(100)
+ * // result1: { bytes: Uint8Array([0x18, 0x64]), hex: '1864' }
+ *
+ * // Encode negative integer
+ * const result2 = encodeNegativeInt(-100)
+ * // result2: { bytes: Uint8Array([0x38, 0x63]), hex: '3863' }
+ *
+ * // Auto-detect integer type
+ * const result3 = encodeInteger(-100)
+ * // result3: { bytes: Uint8Array([0x38, 0x63]), hex: '3863' }
+ * ```
+ */
+declare function useCborIntegerEncoder(): {
+    encodeUnsignedInt: (value: number | bigint) => EncodeResult;
+    encodeNegativeInt: (value: number | bigint) => EncodeResult;
+    encodeInteger: (value: number | bigint) => EncodeResult;
+};
+
+/**
+ * CBOR String Encoder Composable
+ * Handles Major Type 2 (Byte Strings) and Major Type 3 (Text Strings)
+ * Following RFC 8949 specification
+ */
+
+interface StringEncodeOptions {
+    indefinite?: boolean;
+}
+/**
+ * CBOR String Encoder Composable
+ *
+ * Provides functions to encode byte strings and text strings:
+ * - Major Type 2: Byte strings (Uint8Array)
+ * - Major Type 3: Text strings (UTF-8 encoded)
+ *
+ * Supports both definite-length and indefinite-length encoding.
+ *
+ * @param options - Global encoder options
+ *
+ * @example
+ * ```ts
+ * const { encodeByteString, encodeTextString } = useCborStringEncoder()
+ *
+ * // Encode byte string
+ * const bytes = new Uint8Array([0x01, 0x02, 0x03])
+ * const result1 = encodeByteString(bytes)
+ * // result1: { bytes: Uint8Array([0x43, 0x01, 0x02, 0x03]), hex: '43010203' }
+ *
+ * // Encode text string
+ * const result2 = encodeTextString('Hello')
+ * // result2: { bytes: Uint8Array([0x65, 0x48, 0x65, 0x6c, 0x6c, 0x6f]), hex: '6548656c6c6f' }
+ *
+ * // Indefinite-length encoding
+ * const chunks = [new Uint8Array([0xaa]), new Uint8Array([0xbb])]
+ * const result3 = encodeByteStringIndefinite(chunks)
+ * // result3: { bytes: Uint8Array([0x5f, 0x41, 0xaa, 0x41, 0xbb, 0xff]), hex: '5f41aa41bbff' }
+ * ```
+ */
+declare function useCborStringEncoder(globalOptions?: Partial<EncodeOptions>): {
+    encodeByteString: (data: Uint8Array | Uint8Array[] | CborByteString, encodeOptions?: StringEncodeOptions) => EncodeResult;
+    encodeByteStringIndefinite: (chunks: Uint8Array[]) => EncodeResult;
+    encodeTextString: (text: string | CborTextString, encodeOptions?: StringEncodeOptions) => EncodeResult;
+    encodeTextStringIndefinite: (chunks: string[]) => EncodeResult;
+};
+
+/**
+ * CBOR Collection Encoder Composable
+ * Handles Major Type 4 (Arrays) and Major Type 5 (Maps)
+ * Following RFC 8949 specification
+ */
+
+interface CollectionEncodeOptions {
+    indefinite?: boolean;
+}
+/**
+ * CBOR Collection Encoder Composable
+ *
+ * Provides functions to encode arrays and maps:
+ * - Major Type 4: Arrays
+ * - Major Type 5: Maps (objects or Map instances)
+ *
+ * Supports both definite-length and indefinite-length encoding.
+ * Handles canonical encoding with sorted map keys.
+ * Enforces depth and size limits.
+ *
+ * @param options - Global encoder options
+ *
+ * @example
+ * ```ts
+ * const { encodeArray, encodeMap } = useCborCollectionEncoder()
+ *
+ * // Encode array
+ * const arr = [1, 2, 3]
+ * const result1 = encodeArray(arr)
+ * // result1: { bytes: Uint8Array([0x83, 0x01, 0x02, 0x03]), hex: '83010203' }
+ *
+ * // Encode map
+ * const map = { amount: 1000000 }
+ * const result2 = encodeMap(map)
+ * // result2: { bytes: ..., hex: 'a166616d6f756e741a000f4240' }
+ * ```
+ */
+declare function useCborCollectionEncoder(globalOptions?: Partial<EncodeOptions>): {
+    encodeArray: (array: EncodableValue[], encodeOptions?: CollectionEncodeOptions) => EncodeResult;
+    encodeArrayIndefinite: (array: EncodableValue[]) => EncodeResult;
+    encodeMap: (map: Map<EncodableValue, EncodableValue> | {
+        [key: string]: EncodableValue;
+    }, encodeOptions?: CollectionEncodeOptions) => EncodeResult;
+    encodeMapIndefinite: (map: Map<EncodableValue, EncodableValue> | {
+        [key: string]: EncodableValue;
+    }) => EncodeResult;
+    setMainEncode: (encodeFn: (value: EncodableValue) => EncodeResult) => void;
+};
+
+/**
+ * CBOR Simple Values and Floats Encoder Composable
+ * Handles Major Type 7 (Floats and Simple Values)
+ * Following RFC 8949 specification
+ */
+
+/**
+ * CBOR Simple Values and Floats Encoder Composable
+ *
+ * Provides functions to encode:
+ * - Simple values: false, true, null, undefined
+ * - Floating-point numbers: float16, float32, float64
+ *
+ * @param options - Global encoder options
+ *
+ * @example
+ * ```ts
+ * const { encodeSimple, encodeFloat } = useCborSimpleEncoder()
+ *
+ * // Encode simple values
+ * const result1 = encodeSimple(true)
+ * // result1: { bytes: Uint8Array([0xf5]), hex: 'f5' }
+ *
+ * // Encode float
+ * const result2 = encodeFloat(1.1)
+ * // result2: { bytes: Uint8Array([0xfb, ...]), hex: 'fb...' }
+ * ```
+ */
+declare function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>): {
+    encodeSimple: (value: boolean | null | undefined) => EncodeResult;
+    encodeFloat: (value: number, precision?: 16 | 32 | 64) => EncodeResult;
+};
+
+export { DEFAULT_ENCODE_OPTIONS as D, type EncodableValue as E, type TaggedValue as T, type EncodeOptions as a, type EncodeResult as b, useCborIntegerEncoder as c, useCborStringEncoder as d, useCborCollectionEncoder as e, useCborSimpleEncoder as f, type EncodeContext as g, useCborEncoder as u };

package/dist/useCborTag-B_iaShG6.d.ts

@@ -0,0 +1,142 @@
+import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry } from './types-DvNlfbKB.js';
+
+/**
+ * CBOR Main Parser Composable
+ * Orchestrates all CBOR parsers and provides a unified parse interface
+ * Auto-detects major type and dispatches to appropriate parser
+ */
+
+/**
+ * Main CBOR parser composable
+ * Provides a unified interface for parsing any CBOR data
+ *
+ * @returns Object with parse function
+ *
+ * @example
+ * ```ts
+ * const { parse } = useCborParser()
+ * const result = parse('1864') // { value: 100, bytesRead: 2 }
+ * ```
+ */
+declare function useCborParser(): {
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseWithSourceMap: (hexString: string, options?: ParseOptions) => ParseResultWithMap;
+    parseSequence: (hexString: string, options?: ParseOptions) => CborValue[];
+    parseSequenceWithSourceMap: (hexString: string, options?: ParseOptions) => {
+        values: CborValue[];
+        sourceMaps: SourceMapEntry[][];
+    };
+};
+
+/**
+ * CBOR Integer Parser Composable
+ * Handles Major Types 0 (Unsigned) and 1 (Negative)
+ * Supports BigInt for 64-bit values outside Number.MAX_SAFE_INTEGER
+ */
+
+/**
+ * Composable for parsing CBOR integers (Major Types 0 and 1)
+ *
+ * @returns Object with parseInteger function
+ *
+ * @example
+ * ```ts
+ * const { parseInteger } = useCborInteger()
+ * const result = parseInteger('1864') // 100
+ * ```
+ */
+declare function useCborInteger(): {
+    parseInteger: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR String Parser Composable
+ * Handles Major Types 2 (Byte Strings) and 3 (Text Strings)
+ * Supports definite and indefinite length encoding
+ */
+
+/**
+ * Composable for parsing CBOR strings (Major Types 2 and 3)
+ *
+ * @returns Object with string parsing functions
+ *
+ * @example
+ * ```ts
+ * const { parseString } = useCborString()
+ * const result = parseString('6449455446') // "IETF"
+ * ```
+ */
+declare function useCborString(): {
+    parseString: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseByteString: (buffer: Uint8Array, offset?: number, options?: ParseOptions) => ParseResult;
+    parseTextString: (buffer: Uint8Array, offset?: number, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Collection Parser Composable
+ * Handles Major Types 4 (Arrays) and 5 (Maps)
+ * Supports definite and indefinite length encoding
+ */
+
+/**
+ * Composable for parsing CBOR collections (Major Types 4 and 5)
+ *
+ * @returns Object with parseArray and parseMap functions
+ *
+ * @example
+ * ```ts
+ * const { parseArray } = useCborCollection()
+ * const result = parseArray('83010203') // [1, 2, 3]
+ * ```
+ */
+declare function useCborCollection(): {
+    parseArray: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseMap: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Float and Simple Values Parser Composable
+ * Handles Major Type 7 (Simple Values and Floats)
+ * Supports Float16, Float32, Float64, and simple values (true, false, null, undefined)
+ */
+
+/**
+ * Composable for parsing CBOR floats and simple values (Major Type 7)
+ *
+ * @returns Object with parse, parseFloat, and parseSimple functions
+ *
+ * @example
+ * ```ts
+ * const { parse } = useCborFloat()
+ * const result = parse('f5') // true
+ * ```
+ */
+declare function useCborFloat(): {
+    parse: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseFloat: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseSimple: (hexString: string, _options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Tag Parser Composable
+ * Handles Major Type 6 (Semantic Tags)
+ * Supports standard tags (0-5), encoding hints (21-36), self-describe (55799), and Cardano tags
+ */
+
+/**
+ * Composable for parsing CBOR tags (Major Type 6)
+ *
+ * @returns Object with parseTag and parse functions
+ *
+ * @example
+ * ```ts
+ * const { parseTag } = useCborTag()
+ * const result = parseTag('c11a514b67b0') // 1(1363896240) - epoch timestamp
+ * ```
+ */
+declare function useCborTag(): {
+    parseTag: (hexString: string, options?: ParseOptions) => ParseResult;
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+export { useCborInteger as a, useCborString as b, useCborCollection as c, useCborFloat as d, useCborTag as e, useCborParser as u };

package/dist/useCborTag-BfTIV8HM.d.cts

@@ -0,0 +1,142 @@
+import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry } from './types-DvNlfbKB.cjs';
+
+/**
+ * CBOR Main Parser Composable
+ * Orchestrates all CBOR parsers and provides a unified parse interface
+ * Auto-detects major type and dispatches to appropriate parser
+ */
+
+/**
+ * Main CBOR parser composable
+ * Provides a unified interface for parsing any CBOR data
+ *
+ * @returns Object with parse function
+ *
+ * @example
+ * ```ts
+ * const { parse } = useCborParser()
+ * const result = parse('1864') // { value: 100, bytesRead: 2 }
+ * ```
+ */
+declare function useCborParser(): {
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseWithSourceMap: (hexString: string, options?: ParseOptions) => ParseResultWithMap;
+    parseSequence: (hexString: string, options?: ParseOptions) => CborValue[];
+    parseSequenceWithSourceMap: (hexString: string, options?: ParseOptions) => {
+        values: CborValue[];
+        sourceMaps: SourceMapEntry[][];
+    };
+};
+
+/**
+ * CBOR Integer Parser Composable
+ * Handles Major Types 0 (Unsigned) and 1 (Negative)
+ * Supports BigInt for 64-bit values outside Number.MAX_SAFE_INTEGER
+ */
+
+/**
+ * Composable for parsing CBOR integers (Major Types 0 and 1)
+ *
+ * @returns Object with parseInteger function
+ *
+ * @example
+ * ```ts
+ * const { parseInteger } = useCborInteger()
+ * const result = parseInteger('1864') // 100
+ * ```
+ */
+declare function useCborInteger(): {
+    parseInteger: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR String Parser Composable
+ * Handles Major Types 2 (Byte Strings) and 3 (Text Strings)
+ * Supports definite and indefinite length encoding
+ */
+
+/**
+ * Composable for parsing CBOR strings (Major Types 2 and 3)
+ *
+ * @returns Object with string parsing functions
+ *
+ * @example
+ * ```ts
+ * const { parseString } = useCborString()
+ * const result = parseString('6449455446') // "IETF"
+ * ```
+ */
+declare function useCborString(): {
+    parseString: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseByteString: (buffer: Uint8Array, offset?: number, options?: ParseOptions) => ParseResult;
+    parseTextString: (buffer: Uint8Array, offset?: number, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Collection Parser Composable
+ * Handles Major Types 4 (Arrays) and 5 (Maps)
+ * Supports definite and indefinite length encoding
+ */
+
+/**
+ * Composable for parsing CBOR collections (Major Types 4 and 5)
+ *
+ * @returns Object with parseArray and parseMap functions
+ *
+ * @example
+ * ```ts
+ * const { parseArray } = useCborCollection()
+ * const result = parseArray('83010203') // [1, 2, 3]
+ * ```
+ */
+declare function useCborCollection(): {
+    parseArray: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseMap: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Float and Simple Values Parser Composable
+ * Handles Major Type 7 (Simple Values and Floats)
+ * Supports Float16, Float32, Float64, and simple values (true, false, null, undefined)
+ */
+
+/**
+ * Composable for parsing CBOR floats and simple values (Major Type 7)
+ *
+ * @returns Object with parse, parseFloat, and parseSimple functions
+ *
+ * @example
+ * ```ts
+ * const { parse } = useCborFloat()
+ * const result = parse('f5') // true
+ * ```
+ */
+declare function useCborFloat(): {
+    parse: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseFloat: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseSimple: (hexString: string, _options?: ParseOptions) => ParseResult;
+};
+
+/**
+ * CBOR Tag Parser Composable
+ * Handles Major Type 6 (Semantic Tags)
+ * Supports standard tags (0-5), encoding hints (21-36), self-describe (55799), and Cardano tags
+ */
+
+/**
+ * Composable for parsing CBOR tags (Major Type 6)
+ *
+ * @returns Object with parseTag and parse functions
+ *
+ * @example
+ * ```ts
+ * const { parseTag } = useCborTag()
+ * const result = parseTag('c11a514b67b0') // 1(1363896240) - epoch timestamp
+ * ```
+ */
+declare function useCborTag(): {
+    parseTag: (hexString: string, options?: ParseOptions) => ParseResult;
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+};
+
+export { useCborInteger as a, useCborString as b, useCborCollection as c, useCborFloat as d, useCborTag as e, useCborParser as u };

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "@marcuspuchalla/nachos",
+  "version": "0.1.0",
+  "description": "NACHOS - Not Another CBOR Handling Object System. RFC 8949 CBOR encoder/decoder with full source map support for interactive debugging. Zero dependencies, TypeScript, works in Node.js and browsers.",
+  "keywords": [
+    "nachos",
+    "cbor",
+    "codec",
+    "encoder",
+    "decoder",
+    "rfc8949",
+    "serialization",
+    "deserialization",
+    "cardano",
+    "blockchain",
+    "plutus",
+    "binary",
+    "parser",
+    "source-map",
+    "typescript",
+    "zero-dependencies"
+  ],
+  "author": "Marcus Puchalla",
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marcuspuchalla/nachos.git"
+  },
+  "bugs": {
+    "url": "https://github.com/marcuspuchalla/nachos/issues"
+  },
+  "homepage": "https://github.com/marcuspuchalla/nachos#readme",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./parser": {
+      "import": {
+        "types": "./dist/parser/index.d.ts",
+        "default": "./dist/parser/index.js"
+      },
+      "require": {
+        "types": "./dist/parser/index.d.ts",
+        "default": "./dist/parser/index.cjs"
+      }
+    },
+    "./encoder": {
+      "import": {
+        "types": "./dist/encoder/index.d.ts",
+        "default": "./dist/encoder/index.js"
+      },
+      "require": {
+        "types": "./dist/encoder/index.d.ts",
+        "default": "./dist/encoder/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^2.1.8",
+    "tsup": "^8.0.0",
+    "typescript": "~5.6.3",
+    "vitest": "^2.1.8"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}