@atproto/lex-cbor 0.0.8 → 0.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/lex-cbor",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "license": "MIT",
   "description": "Lexicon encoding utilities for AT Lexicon data in CBOR format",
   "keywords": [
@@ -38,13 +38,13 @@
   },
   "dependencies": {
     "tslib": "^2.8.1",
-    "@atproto/lex-data": "0.0.8"
+    "@atproto/lex-data": "^0.0.10"
   },
   "devDependencies": {
-    "cborg": "^4.3.0",
+    "cborg": "^4.5.8",
     "vite": "^6.2.0",
     "vitest": "^4.0.16",
-    "@atproto/lex-json": "0.0.8"
+    "@atproto/lex-json": "^0.0.10"
   },
   "scripts": {
     "dev": "vite build --watch",

package/src/encoding.ts

@@ -8,11 +8,9 @@ import {
   decodeFirst as cborgDecodeFirst,
   encode as cborgEncode,
 } from 'cborg'
+import { OptionalTypeEncoder } from 'cborg/lib/encode'
 import { Cid, LexValue, decodeCid, ifCid } from '@atproto/lex-data'
 
-// @NOTE This was inspired by @ipld/dag-cbor implementation, but adapted to
-// match the AT Data Model constraints. Floats, in particular, are not allowed.
-
 // @NOTE "cborg" version 4 is required to support multi-decoding via the
 // "decodeFirst" function. However, that version only exposes ES modules.
 // Because this package is using "commonjs", "cborg" will be bundled instead of
@@ -20,69 +18,47 @@ import { Cid, LexValue, decodeCid, ifCid } from '@atproto/lex-data'
 
 const CID_CBOR_TAG = 42
 
-function cidEncoder(cid: Cid): Token[] {
-  const bytes = new Uint8Array(cid.bytes.byteLength + 1)
-  bytes.set(cid.bytes, 1) // prefix is 0x00, for historical reasons
-  return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)]
-}
-
-function objectEncoder(
-  obj: object,
-  _typ: string,
-  _options: EncodeOptions,
-): Token[] | null {
-  const cid = ifCid(obj)
-  if (cid) return cidEncoder(cid)
-
-  // @TODO strip undefined values somehow
-  // https://github.com/rvagg/cborg/issues/154
-
-  // Fallback to default object encoder
-  return null
-}
-
-function undefinedEncoder(): null {
-  throw new Error('`undefined` is not allowed by the AT Data Model')
-}
-
-function numberEncoder(num: number): null {
-  if (Number.isInteger(num) && Number.isSafeInteger(num)) return null
-
-  throw new Error('Non-integer numbers are not allowed by the AT Data Model')
-}
+export const encodeOptions = Object.freeze<EncodeOptions>({
+  float64: true,
+  ignoreUndefinedProperties: true,
+  typeEncoders: Object.freeze<{ [typeName: string]: OptionalTypeEncoder }>({
+    Map: (map: Map<unknown, unknown>): null => {
+      for (const key of map.keys()) {
+        if (typeof key !== 'string') {
+          throw new Error(
+            'Only string keys are allowed in CBOR "map" by the AT Data Model',
+          )
+        }
+      }
+
+      // @NOTE Maps will be encoded as CBOR "map", which will be decoded as object.
+      return null
+    },
+    Object: (obj: object): Token[] | null => {
+      const cid = ifCid(obj)
+      if (cid) {
+        const bytes = new Uint8Array(cid.bytes.byteLength + 1)
+        bytes.set(cid.bytes, 1) // prefix is 0x00, for historical reasons
+        return [new Token(Type.tag, CID_CBOR_TAG), new Token(Type.bytes, bytes)]
+      }
+
+      // Fallback to default object encoder
+      return null
+    },
+    undefined: (): null => {
+      throw new Error('`undefined` is not supported by the AT Data Model')
+    },
+    number: (num: number): null => {
+      if (Number.isSafeInteger(num)) return null
 
-function mapEncoder(map: Map<unknown, unknown>): null {
-  for (const key of map.keys()) {
-    if (typeof key !== 'string') {
       throw new Error(
-        'Only string keys are allowed in CBOR "map" by the AT Data Model',
+        `Non-integer numbers (${num}) are not supported by the AT Data Model`,
       )
-    }
-  }
-  // @NOTE Map will be encoded as CBOR "map", which will be decoded as object.
-  return null
-}
+    },
+  }),
+})
 
-const encodeOptions: EncodeOptions = {
-  float64: true,
-  typeEncoders: {
-    Map: mapEncoder,
-    Object: objectEncoder,
-    undefined: undefinedEncoder,
-    number: numberEncoder,
-  },
-}
-
-function cidDecoder(bytes: Uint8Array): Cid {
-  if (bytes[0] !== 0) {
-    throw new Error('Invalid CID for CBOR tag 42; expected leading 0x00')
-  }
-  return decodeCid(bytes.subarray(1)) // ignore leading 0x00
-}
-
-const tagDecoders: TagDecoder[] = []
-tagDecoders[CID_CBOR_TAG] = cidDecoder
-const decodeOptions: DecodeOptions = {
+export const decodeOptions = /*#__PURE__*/ Object.freeze<DecodeOptions>({
   allowIndefinite: false,
   coerceUndefinedToNull: true,
   allowNaN: false,
@@ -91,8 +67,18 @@ const decodeOptions: DecodeOptions = {
   strict: true,
   useMaps: false,
   rejectDuplicateMapKeys: true,
-  tags: tagDecoders,
-}
+  tags: /*#__PURE__*/ Object.freeze<TagDecoder[]>(
+    /*#__PURE__*/ Object.assign([], {
+      [CID_CBOR_TAG]: (bytes: Uint8Array): Cid => {
+        if (bytes[0] !== 0) {
+          throw new Error('Invalid CID for CBOR tag 42; expected leading 0x00')
+        }
+        const cibBytes = bytes.subarray(1) // ignore leading 0x00
+        return decodeCid(cibBytes)
+      },
+    }),
+  ) as TagDecoder[],
+})
 
 export function encode<T extends LexValue = LexValue>(data: T): Uint8Array {
   return cborgEncode(data, encodeOptions)

package/src/index.ts

@@ -9,7 +9,9 @@ export { decode, decodeAll, encode } from './encoding.js'
 export {
   decode as cborDecode,
   decodeAll as cborDecodeAll,
+  decodeOptions,
   encode as cborEncode,
+  encodeOptions,
 } from './encoding.js'
 
 export async function cidForLex(value: LexValue): Promise<CborCid> {