@marcuspuchalla/nachos 0.1.1 → 0.1.4

package/dist/{useCborSimpleEncoder-TVxzNJ_9.d.ts → useCborSimpleEncoder-BoKEmjP9.d.ts}

@@ -56,8 +56,6 @@ interface TaggedValue {
 interface EncodeContext {
     /** Current nesting depth */
     depth: number;
-    /** Bytes written so far */
-    bytesWritten: number;
     /** Encoder options */
     options: Required<EncodeOptions>;
 }

package/dist/{useCborSimpleEncoder-ButVU988.d.cts → useCborSimpleEncoder-C_OHxoB8.d.cts}

@@ -56,8 +56,6 @@ interface TaggedValue {
 interface EncodeContext {
     /** Current nesting depth */
     depth: number;
-    /** Bytes written so far */
-    bytesWritten: number;
     /** Encoder options */
     options: Required<EncodeOptions>;
 }

package/dist/{useCborTag-B_iaShG6.d.ts → useCborTag-BD6Sqp7p.d.ts}

@@ -1,4 +1,4 @@
-import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry } from './types-DvNlfbKB.js';
+import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry, h as PlutusConstr } from './types-DvNlfbKB.js';
 
 /**
  * CBOR Main Parser Composable
@@ -19,9 +19,9 @@ import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as Cbor
  * ```
  */
 declare function useCborParser(): {
-    parse: (hexString: string, options?: ParseOptions) => ParseResult;
-    parseWithSourceMap: (hexString: string, options?: ParseOptions) => ParseResultWithMap;
-    parseSequence: (hexString: string, options?: ParseOptions) => CborValue[];
+    parse: (input: string | Uint8Array, options?: ParseOptions) => ParseResult;
+    parseWithSourceMap: (input: string | Uint8Array, options?: ParseOptions) => ParseResultWithMap;
+    parseSequence: (input: string | Uint8Array, options?: ParseOptions) => CborValue[];
     parseSequenceWithSourceMap: (hexString: string, options?: ParseOptions) => {
         values: CborValue[];
         sourceMaps: SourceMapEntry[][];
@@ -47,6 +47,7 @@ declare function useCborParser(): {
  */
 declare function useCborInteger(): {
     parseInteger: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseIntegerFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions) => ParseResult;
 };
 
 /**
@@ -112,9 +113,10 @@ declare function useCborCollection(): {
  * ```
  */
 declare function useCborFloat(): {
-    parse: (hexString: string, _options?: ParseOptions) => ParseResult;
-    parseFloat: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseFloat: (hexString: string, options?: ParseOptions) => ParseResult;
     parseSimple: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions) => ParseResult;
 };
 
 /**
@@ -137,6 +139,9 @@ declare function useCborFloat(): {
 declare function useCborTag(): {
     parseTag: (hexString: string, options?: ParseOptions) => ParseResult;
     parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseTagFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions, tagDepth?: number) => ParseResult;
+    validateTagSemantics: (tagNumber: number, value: CborValue, options?: ParseOptions) => void;
+    decodePlutusConstructor: (tagNumber: number, value: CborValue) => PlutusConstr | null;
 };
 
 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 → useCborTag-QpZR-Er2.d.cts}

@@ -1,4 +1,4 @@
-import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry } from './types-DvNlfbKB.cjs';
+import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as CborValue, S as SourceMapEntry, h as PlutusConstr } from './types-DvNlfbKB.cjs';
 
 /**
  * CBOR Main Parser Composable
@@ -19,9 +19,9 @@ import { P as ParseOptions, a as ParseResult, b as ParseResultWithMap, e as Cbor
  * ```
  */
 declare function useCborParser(): {
-    parse: (hexString: string, options?: ParseOptions) => ParseResult;
-    parseWithSourceMap: (hexString: string, options?: ParseOptions) => ParseResultWithMap;
-    parseSequence: (hexString: string, options?: ParseOptions) => CborValue[];
+    parse: (input: string | Uint8Array, options?: ParseOptions) => ParseResult;
+    parseWithSourceMap: (input: string | Uint8Array, options?: ParseOptions) => ParseResultWithMap;
+    parseSequence: (input: string | Uint8Array, options?: ParseOptions) => CborValue[];
     parseSequenceWithSourceMap: (hexString: string, options?: ParseOptions) => {
         values: CborValue[];
         sourceMaps: SourceMapEntry[][];
@@ -47,6 +47,7 @@ declare function useCborParser(): {
  */
 declare function useCborInteger(): {
     parseInteger: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseIntegerFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions) => ParseResult;
 };
 
 /**
@@ -112,9 +113,10 @@ declare function useCborCollection(): {
  * ```
  */
 declare function useCborFloat(): {
-    parse: (hexString: string, _options?: ParseOptions) => ParseResult;
-    parseFloat: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseFloat: (hexString: string, options?: ParseOptions) => ParseResult;
     parseSimple: (hexString: string, _options?: ParseOptions) => ParseResult;
+    parseFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions) => ParseResult;
 };
 
 /**
@@ -137,6 +139,9 @@ declare function useCborFloat(): {
 declare function useCborTag(): {
     parseTag: (hexString: string, options?: ParseOptions) => ParseResult;
     parse: (hexString: string, options?: ParseOptions) => ParseResult;
+    parseTagFromBuffer: (buffer: Uint8Array, offset: number, options?: ParseOptions, tagDepth?: number) => ParseResult;
+    validateTagSemantics: (tagNumber: number, value: CborValue, options?: ParseOptions) => void;
+    decodePlutusConstructor: (tagNumber: number, value: CborValue) => PlutusConstr | null;
 };
 
 export { useCborInteger as a, useCborString as b, useCborCollection as c, useCborFloat as d, useCborTag as e, useCborParser as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcuspuchalla/nachos",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "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",

package/src/__tests__/public-api.test.ts

@@ -123,6 +123,14 @@ describe('Public API - Functional Encode', () => {
     expect(result.hex).toBe('010203')
     expect(result.bytes).toEqual(new Uint8Array([0x01, 0x02, 0x03]))
   })
+
+  it('encode() should preserve -0', () => {
+    const result = encode(-0)
+    expect(result.hex).toBe('f98000')
+
+    const decoded = decode(result.hex)
+    expect(Object.is(decoded.value, -0)).toBe(true)
+  })
 })
 
 describe('Public API - Diagnostic Notation', () => {
@@ -277,6 +285,151 @@ describe('Public API - Utilities', () => {
   })
 })
 
+describe('Public API - Uint8Array Decode', () => {
+  it('decode() should accept Uint8Array input for integers', () => {
+    const result = decode(new Uint8Array([0x18, 0x64]))
+    expect(result.value).toBe(100)
+    expect(result.bytesRead).toBe(2)
+  })
+
+  it('decode() should accept Uint8Array for small integers', () => {
+    const result = decode(new Uint8Array([0x01]))
+    expect(result.value).toBe(1)
+    expect(result.bytesRead).toBe(1)
+  })
+
+  it('decode(Uint8Array) should produce identical results to decode(hexString)', () => {
+    // Integer 100
+    const hexResult = decode('1864')
+    const bytesResult = decode(new Uint8Array([0x18, 0x64]))
+    expect(bytesResult.value).toEqual(hexResult.value)
+    expect(bytesResult.bytesRead).toEqual(hexResult.bytesRead)
+
+    // String "IETF"
+    const hexStr = decode('6449455446')
+    const bytesStr = decode(new Uint8Array([0x64, 0x49, 0x45, 0x54, 0x46]))
+    expect(bytesStr.value).toEqual(hexStr.value)
+    expect(bytesStr.bytesRead).toEqual(hexStr.bytesRead)
+
+    // Array [1, 2, 3]
+    const hexArr = decode('83010203')
+    const bytesArr = decode(new Uint8Array([0x83, 0x01, 0x02, 0x03]))
+    expect(bytesArr.value).toEqual(hexArr.value)
+    expect(bytesArr.bytesRead).toEqual(hexArr.bytesRead)
+  })
+
+  it('decode(Uint8Array) should enforce maxInputSize limit', () => {
+    const bytes = new Uint8Array([0x01])
+    // Should succeed with a large enough limit
+    expect(() => decode(bytes, { limits: { maxInputSize: 100 } })).not.toThrow()
+
+    // Should throw when bytes exceed the limit
+    const largeBytes = new Uint8Array(200)
+    largeBytes[0] = 0x01 // valid CBOR integer 1
+    expect(() => decode(largeBytes, { limits: { maxInputSize: 10 } })).toThrow(/exceeds limit/)
+  })
+
+  it('decode(Uint8Array) should handle tagged values', () => {
+    // d87980 = tag 121, empty array
+    const result = decode(new Uint8Array([0xd8, 0x79, 0x80]))
+    expect(result.value).toMatchObject({ tag: 121, value: [] })
+  })
+
+  it('decode(Uint8Array) should handle maps', () => {
+    // a16161 01 = {"a": 1}
+    const result = decode(new Uint8Array([0xa1, 0x61, 0x61, 0x01]))
+    expect(result.bytesRead).toBe(4)
+    // Map with string key "a" -> 1
+    expect(result.value).toBeInstanceOf(Map)
+    expect((result.value as Map<string, number>).get('a')).toBe(1)
+  })
+
+  it('decode(Uint8Array) should handle boolean and null', () => {
+    expect(decode(new Uint8Array([0xf5])).value).toBe(true)
+    expect(decode(new Uint8Array([0xf4])).value).toBe(false)
+    expect(decode(new Uint8Array([0xf6])).value).toBe(null)
+  })
+
+  it('decode(Uint8Array) should reject empty Uint8Array', () => {
+    expect(() => decode(new Uint8Array([]))).toThrow()
+  })
+
+  it('decode(Uint8Array) should accept options', () => {
+    const result = decode(new Uint8Array([0x18, 0x64]), { strict: true })
+    expect(result.value).toBe(100)
+  })
+})
+
+describe('Public API - Uint8Array DecodeWithSourceMap', () => {
+  it('decodeWithSourceMap() should accept Uint8Array input', () => {
+    // d87980 = tag 121, empty array
+    const result = decodeWithSourceMap(new Uint8Array([0xd8, 0x79, 0x80]))
+    expect(result.value).toMatchObject({ tag: 121, value: [] })
+    expect(result.sourceMap).toBeDefined()
+    expect(Array.isArray(result.sourceMap)).toBe(true)
+    expect(result.sourceMap.length).toBeGreaterThan(0)
+  })
+
+  it('decodeWithSourceMap(Uint8Array) should match hex string results', () => {
+    const hexResult = decodeWithSourceMap('d87980')
+    const bytesResult = decodeWithSourceMap(new Uint8Array([0xd8, 0x79, 0x80]))
+    expect(bytesResult.value).toEqual(hexResult.value)
+    expect(bytesResult.sourceMap.length).toBe(hexResult.sourceMap.length)
+  })
+})
+
+describe('Public API - Uint8Array CborDecoder Class', () => {
+  it('CborDecoder.decode() should accept Uint8Array', () => {
+    const decoder = new CborDecoder()
+    const result = decoder.decode(new Uint8Array([0x18, 0x64]))
+    expect(result.value).toBe(100)
+    expect(result.bytesRead).toBe(2)
+  })
+
+  it('CborDecoder.decodeWithSourceMap() should accept Uint8Array', () => {
+    const decoder = new CborDecoder()
+    const result = decoder.decodeWithSourceMap(new Uint8Array([0xd8, 0x79, 0x80]))
+    expect(result.value).toMatchObject({ tag: 121, value: [] })
+    expect(result.sourceMap).toBeDefined()
+  })
+
+  it('CborDecoder with options should work with Uint8Array', () => {
+    const decoder = new CborDecoder({ strict: true })
+    const result = decoder.decode(new Uint8Array([0x18, 0x64]))
+    expect(result.value).toBe(100)
+  })
+})
+
+describe('Public API - Uint8Array useCborParser', () => {
+  it('parse() should accept Uint8Array', () => {
+    const { parse } = useCborParser()
+    const result = parse(new Uint8Array([0x18, 0x64]))
+    expect(result.value).toBe(100)
+    expect(result.bytesRead).toBe(2)
+  })
+
+  it('parseWithSourceMap() should accept Uint8Array', () => {
+    const { parseWithSourceMap } = useCborParser()
+    const result = parseWithSourceMap(new Uint8Array([0xd8, 0x79, 0x80]))
+    expect(result.value).toMatchObject({ tag: 121, value: [] })
+    expect(result.sourceMap).toBeDefined()
+  })
+
+  it('parseSequence() should accept Uint8Array', () => {
+    const { parseSequence } = useCborParser()
+    // Three separate integers: 1, 2, 3
+    const result = parseSequence(new Uint8Array([0x01, 0x02, 0x03]))
+    expect(result).toEqual([1, 2, 3])
+  })
+
+  it('parseSequence(Uint8Array) should match hex string results', () => {
+    const { parseSequence } = useCborParser()
+    const hexResult = parseSequence('010203')
+    const bytesResult = parseSequence(new Uint8Array([0x01, 0x02, 0x03]))
+    expect(bytesResult).toEqual(hexResult)
+  })
+})
+
 describe('Public API - Constants and Enums', () => {
   it('DEFAULT_OPTIONS should be exported', () => {
     expect(DEFAULT_OPTIONS).toBeDefined()