@marcuspuchalla/nachos 0.1.0

package/src/encoder/composables/useCborIntegerEncoder.ts

@@ -0,0 +1,188 @@
+/**
+ * CBOR Integer Encoder Composable
+ * Handles Major Type 0 (Unsigned) and Major Type 1 (Negative)
+ * Following RFC 8949 specification
+ */
+
+import type { EncodeResult } from '../types'
+import { bytesToHex, writeUint, writeBigUint } from '../utils'
+
+/**
+ * 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' }
+ * ```
+ */
+export function useCborIntegerEncoder() {
+  /**
+   * Encode unsigned integer (Major Type 0)
+   *
+   * Encoding rules:
+   * - 0-23: Direct encoding in initial byte (0x00-0x17)
+   * - 24-255: 0x18 + 1 byte
+   * - 256-65535: 0x19 + 2 bytes
+   * - 65536-4294967295: 0x1a + 4 bytes
+   * - 4294967296-2^64-1: 0x1b + 8 bytes
+   *
+   * @param value - Unsigned integer (0 to 2^64-1)
+   * @returns Encoded CBOR bytes and hex string
+   * @throws Error if value is negative or >= 2^64
+   */
+  const encodeUnsignedInt = (value: number | bigint): EncodeResult => {
+    // Convert to BigInt for consistent handling
+    const bigValue = typeof value === 'bigint' ? value : BigInt(value)
+
+    // Validate value is non-negative
+    if (bigValue < 0n) {
+      throw new Error('Cannot encode negative value as unsigned integer')
+    }
+
+    // Validate value doesn't exceed 2^64-1
+    const MAX_UINT64 = 18446744073709551615n  // 2^64 - 1
+    if (bigValue > MAX_UINT64) {
+      throw new Error('Value exceeds maximum unsigned integer (2^64-1)')
+    }
+
+    let bytes: Uint8Array
+
+    // Direct encoding (0-23)
+    if (bigValue <= 23n) {
+      bytes = new Uint8Array([Number(bigValue)])
+    }
+    // 1-byte encoding (24-255)
+    else if (bigValue <= 255n) {
+      bytes = new Uint8Array([0x18, Number(bigValue)])
+    }
+    // 2-byte encoding (256-65535)
+    else if (bigValue <= 65535n) {
+      const valueBytes = writeUint(Number(bigValue), 2)
+      bytes = new Uint8Array([0x19, ...valueBytes])
+    }
+    // 4-byte encoding (65536-4294967295)
+    else if (bigValue <= 4294967295n) {
+      const valueBytes = writeUint(Number(bigValue), 4)
+      bytes = new Uint8Array([0x1a, ...valueBytes])
+    }
+    // 8-byte encoding (> 4294967295)
+    else {
+      const valueBytes = writeBigUint(bigValue, 8)
+      bytes = new Uint8Array([0x1b, ...valueBytes])
+    }
+
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    }
+  }
+
+  /**
+   * Encode negative integer (Major Type 1)
+   *
+   * CBOR encodes negative integers as: -1 - N
+   * where N is the encoded value
+   *
+   * Encoding rules:
+   * - -1 to -24: Direct encoding in initial byte (0x20-0x37)
+   * - -25 to -256: 0x38 + 1 byte
+   * - -257 to -65536: 0x39 + 2 bytes
+   * - -65537 to -4294967296: 0x3a + 4 bytes
+   * - -4294967297 to -2^64: 0x3b + 8 bytes
+   *
+   * @param value - Negative integer (-1 to -2^64)
+   * @returns Encoded CBOR bytes and hex string
+   * @throws Error if value is non-negative or < -2^64
+   */
+  const encodeNegativeInt = (value: number | bigint): EncodeResult => {
+    // Convert to BigInt for consistent handling
+    const bigValue = typeof value === 'bigint' ? value : BigInt(value)
+
+    // Validate value is negative
+    if (bigValue >= 0n) {
+      throw new Error('Cannot encode positive value as negative integer')
+    }
+
+    // Validate value doesn't exceed -2^64
+    const MIN_INT64 = -18446744073709551616n  // -2^64
+    if (bigValue < MIN_INT64) {
+      throw new Error('Value exceeds minimum negative integer (-2^64)')
+    }
+
+    // CBOR encodes negative as: -1 - N
+    // So for value V, we encode N = -1 - V
+    const encoded = -1n - bigValue
+
+    let bytes: Uint8Array
+
+    // Direct encoding (-1 to -24, encoded as 0-23)
+    if (encoded <= 23n) {
+      bytes = new Uint8Array([0x20 + Number(encoded)])
+    }
+    // 1-byte encoding (-25 to -256, encoded as 24-255)
+    else if (encoded <= 255n) {
+      bytes = new Uint8Array([0x38, Number(encoded)])
+    }
+    // 2-byte encoding (-257 to -65536, encoded as 256-65535)
+    else if (encoded <= 65535n) {
+      const valueBytes = writeUint(Number(encoded), 2)
+      bytes = new Uint8Array([0x39, ...valueBytes])
+    }
+    // 4-byte encoding (-65537 to -4294967296, encoded as 65536-4294967295)
+    else if (encoded <= 4294967295n) {
+      const valueBytes = writeUint(Number(encoded), 4)
+      bytes = new Uint8Array([0x3a, ...valueBytes])
+    }
+    // 8-byte encoding (< -4294967296)
+    else {
+      const valueBytes = writeBigUint(encoded, 8)
+      bytes = new Uint8Array([0x3b, ...valueBytes])
+    }
+
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    }
+  }
+
+  /**
+   * Encode integer (auto-detect type)
+   *
+   * Automatically selects Major Type 0 (unsigned) or Major Type 1 (negative)
+   * based on the sign of the value.
+   *
+   * @param value - Any integer
+   * @returns Encoded CBOR bytes and hex string
+   */
+  const encodeInteger = (value: number | bigint): EncodeResult => {
+    const bigValue = typeof value === 'bigint' ? value : BigInt(value)
+
+    if (bigValue < 0n) {
+      return encodeNegativeInt(bigValue)
+    } else {
+      return encodeUnsignedInt(bigValue)
+    }
+  }
+
+  return {
+    encodeUnsignedInt,
+    encodeNegativeInt,
+    encodeInteger
+  }
+}

package/src/encoder/composables/useCborSimpleEncoder.ts

@@ -0,0 +1,266 @@
+/**
+ * CBOR Simple Values and Floats Encoder Composable
+ * Handles Major Type 7 (Floats and Simple Values)
+ * Following RFC 8949 specification
+ */
+
+import type { EncodeResult, EncodeOptions } from '../types'
+import { bytesToHex } from '../utils'
+import { useCborIntegerEncoder } from './useCborIntegerEncoder'
+
+/**
+ * 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...' }
+ * ```
+ */
+export function useCborSimpleEncoder(_globalOptions?: Partial<EncodeOptions>) {
+  const { encodeInteger } = useCborIntegerEncoder()
+
+  /**
+   * Encode simple values (booleans, null, undefined)
+   *
+   * @param value - Simple value to encode
+   * @returns Encoded CBOR bytes and hex string
+   */
+  const encodeSimple = (value: boolean | null | undefined): EncodeResult => {
+    let byte: number
+
+    if (value === false) {
+      byte = 0xf4
+    } else if (value === true) {
+      byte = 0xf5
+    } else if (value === null) {
+      byte = 0xf6
+    } else if (value === undefined) {
+      byte = 0xf7
+    } else {
+      throw new Error(`Unsupported simple value: ${value}`)
+    }
+
+    return {
+      bytes: new Uint8Array([byte]),
+      hex: bytesToHex(new Uint8Array([byte]))
+    }
+  }
+
+  /**
+   * Encode float16 (IEEE 754 half precision)
+   *
+   * @param value - Number to encode
+   * @returns Uint8Array with float16 bytes (2 bytes)
+   */
+  const encodeFloat16Bytes = (value: number): Uint8Array => {
+    // Handle special cases
+    if (value === 0) return new Uint8Array([0x00, 0x00])
+    if (value === -0) return new Uint8Array([0x80, 0x00])
+    if (Number.isNaN(value)) return new Uint8Array([0x7e, 0x00])
+    if (value === Infinity) return new Uint8Array([0x7c, 0x00])
+    if (value === -Infinity) return new Uint8Array([0xfc, 0x00])
+
+    // Convert float64 to float16
+    const sign = value < 0 ? 1 : 0
+    const absValue = Math.abs(value)
+
+    // Get exponent and mantissa from float64
+    const buffer = new ArrayBuffer(8)
+    const view = new DataView(buffer)
+    view.setFloat64(0, absValue, false)
+
+    const bits = view.getBigUint64(0, false)
+    const exp64 = Number((bits >> 52n) & 0x7ffn) - 1023
+    const mant64 = Number(bits & 0xfffffffffffffn)
+
+    // Convert to float16 range
+    let exp16: number
+    let mant16: number
+
+    if (exp64 < -14) {
+      // Subnormal or zero
+      exp16 = 0
+      mant16 = 0
+    } else if (exp64 > 15) {
+      // Overflow to infinity
+      exp16 = 31
+      mant16 = 0
+    } else {
+      // Normal number
+      exp16 = exp64 + 15
+      // Take top 10 bits of mantissa
+      mant16 = mant64 >> 42
+    }
+
+    const float16 = (sign << 15) | (exp16 << 10) | mant16
+
+    return new Uint8Array([
+      (float16 >> 8) & 0xff,
+      float16 & 0xff
+    ])
+  }
+
+  /**
+   * Encode float32 (IEEE 754 single precision)
+   *
+   * @param value - Number to encode
+   * @returns Uint8Array with float32 bytes (4 bytes)
+   */
+  const encodeFloat32Bytes = (value: number): Uint8Array => {
+    const buffer = new ArrayBuffer(4)
+    const view = new DataView(buffer)
+    view.setFloat32(0, value, false)  // Big-endian
+
+    return new Uint8Array(buffer)
+  }
+
+  /**
+   * Encode float64 (IEEE 754 double precision)
+   *
+   * @param value - Number to encode
+   * @returns Uint8Array with float64 bytes (8 bytes)
+   */
+  const encodeFloat64Bytes = (value: number): Uint8Array => {
+    const buffer = new ArrayBuffer(8)
+    const view = new DataView(buffer)
+    view.setFloat64(0, value, false)  // Big-endian
+
+    return new Uint8Array(buffer)
+  }
+
+  /**
+   * Check if a number can be exactly represented as float16
+   *
+   * @param value - Number to check
+   * @returns True if can be represented as float16
+   */
+  const canBeFloat16 = (value: number): boolean => {
+    // Special values
+    if (!Number.isFinite(value) || value === 0 || value === -0) {
+      return true
+    }
+
+    // Check range
+    const absValue = Math.abs(value)
+    if (absValue < 0.00006103515625 || absValue > 65504) {
+      return false
+    }
+
+    // Encode and decode to check for precision loss
+    const bytes = encodeFloat16Bytes(value)
+    const view = new DataView(bytes.buffer)
+    const bits = view.getUint16(0, false)
+
+    const sign = (bits >> 15) & 0x1
+    const exp = (bits >> 10) & 0x1f
+    const mant = bits & 0x3ff
+
+    let decoded: number
+
+    if (exp === 0) {
+      decoded = (sign ? -1 : 1) * Math.pow(2, -14) * (mant / 1024)
+    } else if (exp === 31) {
+      decoded = mant === 0 ? (sign ? -Infinity : Infinity) : NaN
+    } else {
+      decoded = (sign ? -1 : 1) * Math.pow(2, exp - 15) * (1 + mant / 1024)
+    }
+
+    return decoded === value
+  }
+
+  /**
+   * Check if a number can be exactly represented as float32
+   *
+   * @param value - Number to check
+   * @returns True if can be represented as float32
+   */
+  const canBeFloat32 = (value: number): boolean => {
+    // Special values
+    if (!Number.isFinite(value) || value === 0 || value === -0) {
+      return true
+    }
+
+    // Encode as float32 and decode back to check for precision loss
+    const buffer = new ArrayBuffer(4)
+    const view = new DataView(buffer)
+    view.setFloat32(0, value, false)
+    const decoded = view.getFloat32(0, false)
+
+    return decoded === value
+  }
+
+  /**
+   * Check if a number is an integer
+   *
+   * @param value - Number to check
+   * @returns True if value is an integer
+   */
+  const isInteger = (value: number): boolean => {
+    return Number.isInteger(value) && Number.isSafeInteger(value)
+  }
+
+  /**
+   * Encode floating-point number
+   *
+   * @param value - Number to encode
+   * @param precision - Optional precision (16, 32, or 64). If not specified, uses smallest possible.
+   * @returns Encoded CBOR bytes and hex string
+   */
+  const encodeFloat = (value: number, precision?: 16 | 32 | 64): EncodeResult => {
+    let bytes: Uint8Array
+
+    // If value is an integer, encode as integer
+    if (isInteger(value) && !precision) {
+      return encodeInteger(value)
+    }
+
+    // If precision is specified, use it
+    if (precision === 16) {
+      const floatBytes = encodeFloat16Bytes(value)
+      bytes = new Uint8Array([0xf9, ...floatBytes])
+    } else if (precision === 32) {
+      const floatBytes = encodeFloat32Bytes(value)
+      bytes = new Uint8Array([0xfa, ...floatBytes])
+    } else if (precision === 64) {
+      const floatBytes = encodeFloat64Bytes(value)
+      bytes = new Uint8Array([0xfb, ...floatBytes])
+    } else {
+      // Auto-detect smallest precision
+      if (canBeFloat16(value)) {
+        const floatBytes = encodeFloat16Bytes(value)
+        bytes = new Uint8Array([0xf9, ...floatBytes])
+      } else if (canBeFloat32(value)) {
+        const floatBytes = encodeFloat32Bytes(value)
+        bytes = new Uint8Array([0xfa, ...floatBytes])
+      } else {
+        // Use float64 for best precision
+        const floatBytes = encodeFloat64Bytes(value)
+        bytes = new Uint8Array([0xfb, ...floatBytes])
+      }
+    }
+
+    return {
+      bytes,
+      hex: bytesToHex(bytes)
+    }
+  }
+
+  return {
+    encodeSimple,
+    encodeFloat
+  }
+}