@atcute/cbor 2.0.0 → 2.1.0

package/lib/encode.ts

@@ -1,102 +1,142 @@
 import { CidLinkWrapper, fromString, type CidLink } from '@atcute/cid';
+import { allocUnsafe, concat, encodeUtf8Into } from '@atcute/uint8array';
 
 import { BytesWrapper, fromBytes, type Bytes } from './bytes.js';
 
+const MAX_TYPE_ARG_LEN = 9;
 const CHUNK_SIZE = 1024;
 
-const utf8e = new TextEncoder();
-
 interface State {
 	c: Uint8Array[];
-	b: ArrayBuffer;
-	v: DataView;
+	b: Uint8Array;
 	p: number;
+	l: number;
 }
 
+const _abs = Math.abs;
+const _floor = Math.floor;
+const _log2 = Math.log2;
+const _max = Math.max;
+
+const _isInteger = Number.isInteger;
+const _isNaN = Number.isNaN;
+
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER;
+
 const resizeIfNeeded = (state: State, needed: number): void => {
 	const buf = state.b;
 	const pos = state.p;
 
 	if (buf.byteLength < pos + needed) {
-		state.c.push(new Uint8Array(buf, 0, pos));
+		state.c.push(buf.subarray(0, pos));
+		state.l += pos;
 
-		state.b = new ArrayBuffer(Math.max(CHUNK_SIZE, needed));
-		state.v = new DataView(state.b);
+		state.b = allocUnsafe(_max(CHUNK_SIZE, needed));
 		state.p = 0;
 	}
 };
 
-const getInfo = (arg: number): number => {
-	if (arg < 24) {
-		return arg;
-	} else if (arg < 0x100) {
-		return 24;
-	} else if (arg < 0x10000) {
-		return 25;
-	} else if (arg < 0x100000000) {
-		return 26;
-	} else {
-		return 27;
-	}
+const getTypeInfoLength = (arg: number): number => {
+	return arg < 24 ? 1 : arg < 0x100 ? 2 : arg < 0x10000 ? 3 : arg < 0x100000000 ? 5 : 9;
 };
 
 const writeFloat64 = (state: State, val: number): void => {
-	resizeIfNeeded(state, 8);
+	let pos = state.p;
+	const buf = state.b;
 
-	state.v.setFloat64(state.p, val);
-	state.p += 8;
+	const sign = val < 0 ? 1 : 0;
+	val = _abs(val);
+
+	const exp = _floor(_log2(val));
+	let frac = val / 2 ** exp - 1;
+
+	const biasedExp = exp + 1023;
+
+	buf[pos++] = (sign << 7) | (biasedExp >>> 4);
+	buf[pos++] = ((biasedExp & 0xf) << 4) | ((frac * 16) >>> 0);
+
+	frac *= 16;
+	for (let i = 0; i < 6; i++) {
+		frac = (frac % 1) * 256;
+		buf[pos++] = frac >>> 0;
+	}
+
+	state.p = pos;
 };
 
 const writeUint8 = (state: State, val: number): void => {
-	resizeIfNeeded(state, 1);
-
-	state.v.setUint8(state.p, val);
-	state.p += 1;
+	state.b[state.p++] = val;
 };
 
 const writeUint16 = (state: State, val: number): void => {
-	resizeIfNeeded(state, 2);
+	let pos = state.p;
+
+	const buf = state.b;
+
+	buf[pos++] = val >>> 8;
+	buf[pos++] = val & 0xff;
 
-	state.v.setUint16(state.p, val);
-	state.p += 2;
+	state.p = pos;
 };
 
 const writeUint32 = (state: State, val: number): void => {
-	resizeIfNeeded(state, 4);
+	let pos = state.p;
 
-	state.v.setUint32(state.p, val);
-	state.p += 4;
+	const buf = state.b;
+
+	buf[pos++] = val >>> 24;
+	buf[pos++] = (val >>> 16) & 0xff;
+	buf[pos++] = (val >>> 8) & 0xff;
+	buf[pos++] = val & 0xff;
+
+	state.p = pos;
 };
 
 const writeUint64 = (state: State, val: number): void => {
+	let pos = state.p;
+
+	const buf = state.b;
+
 	const hi = (val / 2 ** 32) | 0;
 	const lo = val >>> 0;
 
-	resizeIfNeeded(state, 8);
+	buf[pos++] = hi >>> 24;
+	buf[pos++] = (hi >>> 16) & 0xff;
+	buf[pos++] = (hi >>> 8) & 0xff;
+	buf[pos++] = hi & 0xff;
 
-	state.v.setUint32(state.p, hi);
-	state.v.setUint32(state.p + 4, lo);
-	state.p += 8;
+	buf[pos++] = lo >>> 24;
+	buf[pos++] = (lo >>> 16) & 0xff;
+	buf[pos++] = (lo >>> 8) & 0xff;
+	buf[pos++] = lo & 0xff;
+
+	state.p = pos;
 };
 
 const writeTypeAndArgument = (state: State, type: number, arg: number): void => {
-	const info = getInfo(arg);
-
-	writeUint8(state, (type << 5) | info);
-
-	switch (info) {
-		case 24:
-			return writeUint8(state, arg);
-		case 25:
-			return writeUint16(state, arg);
-		case 26:
-			return writeUint32(state, arg);
-		case 27:
-			return writeUint64(state, arg);
+	if (arg < 24) {
+		writeUint8(state, (type << 5) | arg);
+	} else if (arg < 0x100) {
+		writeUint8(state, (type << 5) | 24);
+		writeUint8(state, arg);
+	} else if (arg < 0x10000) {
+		writeUint8(state, (type << 5) | 25);
+		writeUint16(state, arg);
+	} else if (arg < 0x100000000) {
+		writeUint8(state, (type << 5) | 26);
+		writeUint32(state, arg);
+	} else {
+		writeUint8(state, (type << 5) | 27);
+		writeUint64(state, arg);
 	}
 };
 
+// --- Functions below MUST be cautious about ensuring there's enough room in the buffer!!
+
 const writeInteger = (state: State, val: number): void => {
+	resizeIfNeeded(state, MAX_TYPE_ARG_LEN);
+
 	if (val < 0) {
 		writeTypeAndArgument(state, 1, -val - 1);
 	} else {
@@ -105,35 +145,55 @@ const writeInteger = (state: State, val: number): void => {
 };
 
 const writeFloat = (state: State, val: number): void => {
+	resizeIfNeeded(state, 9);
+
 	writeUint8(state, 0xe0 | 27);
 	writeFloat64(state, val);
 };
 
 const writeNumber = (state: State, val: number): void => {
-	if (Number.isNaN(val)) {
+	if (_isNaN(val)) {
 		throw new RangeError(`NaN values not supported`);
 	}
 
-	if (val > Number.MAX_SAFE_INTEGER || val < Number.MIN_SAFE_INTEGER) {
+	if (val > MAX_SAFE_INTEGER || val < MIN_SAFE_INTEGER) {
 		throw new RangeError(`can't encode numbers beyond safe integer range`);
 	}
 
-	if (Number.isInteger(val)) {
+	if (_isInteger(val)) {
 		writeInteger(state, val);
 	} else {
+		// Note: https://atproto.com/specs/data-model#:~:text=not%20allowed%20in%20atproto
 		writeFloat(state, val);
 	}
 };
 
 const writeString = (state: State, val: string): void => {
-	const buf = utf8e.encode(val);
-	const len = buf.byteLength;
+	// JS strings are UTF-16 (ECMA spec)
+	// Therefore, worst case length of UTF-8 is length * 3. (plus 9 bytes of CBOR header)
+	// Greatly overshoots in practice, but doesn't matter. (alloc is O(1)+ anyway)
+	const strLength = val.length;
+	resizeIfNeeded(state, strLength * 3 + MAX_TYPE_ARG_LEN);
+
+	// Credit: method used by cbor-x
+	// Rather than allocate a buffer and then copy it back to the destination buffer:
+	// - Estimate the length of the header based on the UTF-16 size of the string.
+	//   Should be accurate most of the time, see last point for when it isn't.
+	// - Directly write the string at the estimated location, retrieving with it the actual length.
+	// - Write the header now that the length is available.
+	//   - If the estimation happened to be wrong, correct the placement of the string.
+	//     While it's costly, it's actually roughly the same cost as if we encoded it separately + copy.
+	const estimatedHeaderSize = getTypeInfoLength(strLength);
+	const estimatedPosition = state.p + estimatedHeaderSize;
+	const len = encodeUtf8Into(state.b, val, estimatedPosition);
+
+	const headerSize = getTypeInfoLength(len);
+	if (estimatedHeaderSize !== headerSize) {
+		// Estimation was incorrect, move the bytes to the real place.
+		state.b.copyWithin(state.p + headerSize, estimatedPosition, estimatedPosition + len);
+	}
 
 	writeTypeAndArgument(state, 3, len);
-	resizeIfNeeded(state, len);
-
-	new Uint8Array(state.b, state.p).set(buf);
-
 	state.p += len;
 };
 
@@ -141,11 +201,10 @@ const writeBytes = (state: State, val: Bytes): void => {
 	const buf = fromBytes(val);
 	const len = buf.byteLength;
 
-	writeTypeAndArgument(state, 2, len);
-	resizeIfNeeded(state, len);
-
-	new Uint8Array(state.b, state.p, len).set(buf);
+	resizeIfNeeded(state, len + MAX_TYPE_ARG_LEN);
 
+	writeTypeAndArgument(state, 2, len);
+	state.b.set(buf, state.p);
 	state.p += len;
 };
 
@@ -155,90 +214,86 @@ const writeCid = (state: State, val: CidLink): void => {
 	const buf = val instanceof CidLinkWrapper ? val.bytes : fromString(val.$link).bytes;
 	const len = buf.byteLength + 1;
 
+	resizeIfNeeded(state, len + 2 * MAX_TYPE_ARG_LEN);
+
 	writeTypeAndArgument(state, 6, 42);
 	writeTypeAndArgument(state, 2, len);
 
-	resizeIfNeeded(state, len);
-
-	new Uint8Array(state.b, state.p + 1, len - 1).set(buf);
+	state.b[state.p] = 0;
+	state.b.set(buf, state.p + 1);
 
 	state.p += len;
 };
 
 const writeValue = (state: State, val: any): void => {
-	if (val === undefined) {
-		throw new TypeError(`undefined values not supported`);
-	}
-
-	if (val === null) {
-		return writeUint8(state, 0xf6);
-	}
-
-	if (val === false) {
-		return writeUint8(state, 0xf4);
-	}
-
-	if (val === true) {
-		return writeUint8(state, 0xf5);
-	}
-
-	if (typeof val === 'number') {
-		return writeNumber(state, val);
-	}
-
-	if (typeof val === 'string') {
-		return writeString(state, val);
-	}
+	switch (typeof val) {
+		case 'boolean': {
+			resizeIfNeeded(state, 1);
+			return writeUint8(state, 0xf4 + +val);
+		}
+		case 'number': {
+			return writeNumber(state, val);
+		}
+		case 'string': {
+			return writeString(state, val);
+		}
+		case 'object': {
+			// case: null
+			if (val === null) {
+				resizeIfNeeded(state, 1);
+				return writeUint8(state, 0xf6);
+			}
 
-	if (typeof val === 'object') {
-		if (isArray(val)) {
-			const len = val.length;
+			// case: array
+			if (Array.isArray(val)) {
+				const len = val.length;
+				resizeIfNeeded(state, MAX_TYPE_ARG_LEN);
+				writeTypeAndArgument(state, 4, len);
 
-			writeTypeAndArgument(state, 4, len);
+				for (let idx = 0; idx < len; idx++) {
+					writeValue(state, val[idx]);
+				}
 
-			for (let idx = 0; idx < len; idx++) {
-				const v = val[idx];
-				writeValue(state, v);
+				return;
 			}
 
-			return;
-		}
+			// case: cid-link
+			if ('$link' in val) {
+				if (val instanceof CidLinkWrapper || typeof val.$link === 'string') {
+					writeCid(state, val);
+					return;
+				}
 
-		if ('$link' in val) {
-			if (val instanceof CidLinkWrapper || typeof val.$link === 'string') {
-				writeCid(state, val);
-				return;
+				throw new TypeError(`unexpected cid-link value`);
 			}
 
-			throw new TypeError(`unexpected cid-link value`);
-		}
+			// case: bytes
+			if ('$bytes' in val) {
+				if (val instanceof BytesWrapper || typeof val.$bytes === 'string') {
+					writeBytes(state, val);
+					return;
+				}
 
-		if ('$bytes' in val) {
-			if (val instanceof BytesWrapper || typeof val.$bytes === 'string') {
-				writeBytes(state, val);
-				return;
+				throw new TypeError(`unexpected bytes value`);
 			}
 
-			throw new TypeError(`unexpected bytes value`);
-		}
-
-		if (isPlainObject(val)) {
-			const keys = Object.keys(val)
-				.filter((key) => typeof key === 'string' && val[key] !== undefined)
-				.sort(compareKeys);
+			// case: POJO
+			if (val.constructor === Object) {
+				const keys = getOrderedObjectKeys(val);
+				const len = keys.length;
 
-			const len = keys.length;
+				resizeIfNeeded(state, MAX_TYPE_ARG_LEN);
+				writeTypeAndArgument(state, 5, len);
 
-			writeTypeAndArgument(state, 5, len);
+				for (let idx = 0; idx < len; idx++) {
+					const key = keys[idx];
 
-			for (let idx = 0; idx < len; idx++) {
-				const key = keys[idx];
+					writeString(state, key);
+					writeValue(state, val[key]);
+				}
 
-				writeString(state, key);
-				writeValue(state, val[key]);
+				return;
 			}
-
-			return;
 		}
 	}
 
@@ -246,61 +301,53 @@ const writeValue = (state: State, val: any): void => {
 };
 
 const createState = (): State => {
-	const buf = new ArrayBuffer(CHUNK_SIZE);
+	const buf = allocUnsafe(CHUNK_SIZE);
 
 	return {
 		c: [],
 		b: buf,
-		v: new DataView(buf),
 		p: 0,
+		l: 0,
 	};
 };
 
 export const encode = (value: any): Uint8Array => {
 	const state = createState();
-	const chunks = state.c;
 
 	writeValue(state, value);
-	chunks.push(new Uint8Array(state.b, 0, state.p));
-
-	let size = 0;
-	let written = 0;
-
-	let len = chunks.length;
-	let idx: number;
-
-	for (idx = 0; idx < len; idx++) {
-		size += chunks[idx].byteLength;
-	}
-
-	const u8 = new Uint8Array(size);
 
-	for (idx = 0; idx < len; idx++) {
-		const chunk = chunks[idx];
-
-		u8.set(chunk, written);
-		written += chunk.byteLength;
-	}
-
-	return u8;
+	state.c.push(state.b.subarray(0, state.p));
+	return concat(state.c, state.l + state.p);
 };
 
-const isArray = Array.isArray;
-const isPlainObject = (v: any): boolean => {
-	if (typeof v !== 'object' || v === null) {
-		return false;
-	}
-
-	const proto = Object.getPrototypeOf(v);
-	return proto === Object.prototype || proto === null;
-};
+/** @internal */
+export const getOrderedObjectKeys = (obj: Record<string, unknown>): string[] => {
+	const keys = Object.keys(obj);
+	for (let i = 1, len = keys.length, j = 0; i < len; j = i++) {
+		const valA = keys[i];
+
+		// Tuck in undefined value filtering here to avoid extra iterations.
+		if (obj[valA] === undefined) {
+			// A lot of things are tucked in here xd
+			// - Pull the currently last item in the keys array at the current place
+			// - Update saved value of array length
+			// - Decrease i by 1
+			keys[i--] = keys[--len];
+			keys.length = len;
+		} else {
+			for (; j >= 0; j--) {
+				const valB = keys[j];
+
+				// Note: Don't need to check for equality, keys are always distinct.
+				const cmp = valA.length - valB.length || +(valA > valB);
+				if (cmp > 0) break;
+
+				keys[j + 1] = valB;
+			}
 
-const compareKeys = (a: string, b: string): number => {
-	if (a.length < b.length) {
-		return -1;
-	} else if (b.length < a.length) {
-		return 1;
-	} else {
-		return a < b ? -1 : 1;
+			keys[j + 1] = valA;
+		}
 	}
+
+	return keys;
 };

package/package.json

@@ -1,8 +1,13 @@
 {
   "type": "module",
   "name": "@atcute/cbor",
-  "version": "2.0.0",
-  "description": "DAG-CBOR codec that deals in AT Protocol's HTTP wire format",
+  "version": "2.1.0",
+  "description": "lightweight DASL dCBOR42 codec library for AT Protocol",
+  "keywords": [
+    "atproto",
+    "dasl",
+    "cbor"
+  ],
   "license": "MIT",
   "repository": {
     "url": "https://github.com/mary-ext/atcute",
@@ -19,16 +24,17 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@ipld/dag-cbor": "^9.2.1",
-    "@types/bun": "^1.1.12",
-    "mitata": "^1.0.10"
+    "@ipld/dag-cbor": "^9.2.2",
+    "@types/bun": "^1.1.14",
+    "cbor-x": "^1.6.0"
   },
   "dependencies": {
-    "@atcute/cid": "^2.0.0",
-    "@atcute/multibase": "^1.0.1"
+    "@atcute/cid": "^2.1.0",
+    "@atcute/uint8array": "^1.0.0",
+    "@atcute/multibase": "^1.1.0"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
+    "build": "rm -rf dist; tsc --project tsconfig.build.json",
     "test": "bun test --coverage",
     "prepublish": "rm -rf dist; pnpm run build"
   }