@atproto/lex-data 0.0.3 → 0.0.5

package/src/uint8array-concat.test.ts

@@ -0,0 +1,197 @@
+import { assert, describe, expect, it } from 'vitest'
+import { ui8ConcatNode, ui8ConcatPonyfill } from './uint8array-concat.js'
+import { ui8Equals } from './uint8array.js'
+
+for (const ui8Concat of [ui8ConcatNode, ui8ConcatPonyfill] as const) {
+  // Tests should run in NodeJS where implementations are available.
+  assert(ui8Concat, 'ui8Concat implementation should not be undefined')
+
+  describe(ui8Concat.name, () => {
+    describe('empty array', () => {
+      it('returns empty Uint8Array when given empty array', () => {
+        const result = ui8Concat([])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(result.length).toBe(0)
+      })
+    })
+
+    describe('single array', () => {
+      it('returns copy of single Uint8Array', () => {
+        const input = new Uint8Array([1, 2, 3])
+        const result = ui8Concat([input])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, input)).toBe(true)
+      })
+
+      it('returns copy of single empty Uint8Array', () => {
+        const input = new Uint8Array(0)
+        const result = ui8Concat([input])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(result.length).toBe(0)
+      })
+    })
+
+    describe('multiple arrays', () => {
+      it('concatenates two arrays', () => {
+        const a = new Uint8Array([1, 2, 3])
+        const b = new Uint8Array([4, 5, 6])
+        const result = ui8Concat([a, b])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6]))).toBe(true)
+      })
+
+      it('concatenates three arrays', () => {
+        const a = new Uint8Array([1, 2])
+        const b = new Uint8Array([3, 4])
+        const c = new Uint8Array([5, 6])
+        const result = ui8Concat([a, b, c])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6]))).toBe(true)
+      })
+
+      it('concatenates many arrays', () => {
+        const arrays = [
+          new Uint8Array([0x00]),
+          new Uint8Array([0x01, 0x02]),
+          new Uint8Array([0x03, 0x04, 0x05]),
+          new Uint8Array([0x06, 0x07, 0x08, 0x09]),
+          new Uint8Array([0x0a]),
+        ]
+        const result = ui8Concat(arrays)
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(
+          ui8Equals(
+            result,
+            new Uint8Array([
+              0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+            ]),
+          ),
+        ).toBe(true)
+      })
+    })
+
+    describe('arrays with different lengths', () => {
+      it('concatenates arrays of varying lengths', () => {
+        const a = new Uint8Array([1])
+        const b = new Uint8Array([2, 3, 4, 5, 6])
+        const c = new Uint8Array([7, 8])
+        const result = ui8Concat([a, b, c])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(
+          ui8Equals(result, new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8])),
+        ).toBe(true)
+      })
+
+      it('handles large arrays', () => {
+        const size = 10000
+        const a = new Uint8Array(size).fill(0xaa)
+        const b = new Uint8Array(size).fill(0xbb)
+        const result = ui8Concat([a, b])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(result.length).toBe(size * 2)
+        // Check first array portion
+        for (let i = 0; i < size; i++) {
+          expect(result[i]).toBe(0xaa)
+        }
+        // Check second array portion
+        for (let i = size; i < size * 2; i++) {
+          expect(result[i]).toBe(0xbb)
+        }
+      })
+    })
+
+    describe('empty Uint8Arrays in input', () => {
+      it('handles empty array at the beginning', () => {
+        const a = new Uint8Array(0)
+        const b = new Uint8Array([1, 2, 3])
+        const result = ui8Concat([a, b])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2, 3]))).toBe(true)
+      })
+
+      it('handles empty array in the middle', () => {
+        const a = new Uint8Array([1, 2])
+        const b = new Uint8Array(0)
+        const c = new Uint8Array([3, 4])
+        const result = ui8Concat([a, b, c])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2, 3, 4]))).toBe(true)
+      })
+
+      it('handles empty array at the end', () => {
+        const a = new Uint8Array([1, 2, 3])
+        const b = new Uint8Array(0)
+        const result = ui8Concat([a, b])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2, 3]))).toBe(true)
+      })
+
+      it('handles multiple empty arrays', () => {
+        const a = new Uint8Array(0)
+        const b = new Uint8Array([1])
+        const c = new Uint8Array(0)
+        const d = new Uint8Array([2])
+        const e = new Uint8Array(0)
+        const result = ui8Concat([a, b, c, d, e])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([1, 2]))).toBe(true)
+      })
+
+      it('handles all empty arrays', () => {
+        const a = new Uint8Array(0)
+        const b = new Uint8Array(0)
+        const c = new Uint8Array(0)
+        const result = ui8Concat([a, b, c])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(result.length).toBe(0)
+      })
+    })
+
+    describe('byte value preservation', () => {
+      it('preserves all byte values from 0x00 to 0xff', () => {
+        const allBytes = new Uint8Array(256)
+        for (let i = 0; i < 256; i++) {
+          allBytes[i] = i
+        }
+        const result = ui8Concat([allBytes])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, allBytes)).toBe(true)
+      })
+
+      it('preserves boundary byte values in concatenation', () => {
+        const a = new Uint8Array([0x00, 0x01, 0x7f])
+        const b = new Uint8Array([0x80, 0xfe, 0xff])
+        const result = ui8Concat([a, b])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(
+          ui8Equals(
+            result,
+            new Uint8Array([0x00, 0x01, 0x7f, 0x80, 0xfe, 0xff]),
+          ),
+        ).toBe(true)
+      })
+    })
+
+    describe('subarray handling', () => {
+      it('correctly concatenates subarrays', () => {
+        const fullArray = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+        const sub1 = fullArray.subarray(0, 3) // [0, 1, 2]
+        const sub2 = fullArray.subarray(5, 8) // [5, 6, 7]
+        const result = ui8Concat([sub1, sub2])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([0, 1, 2, 5, 6, 7]))).toBe(true)
+      })
+
+      it('correctly concatenates subarray with regular array', () => {
+        const fullArray = new Uint8Array([10, 20, 30, 40, 50])
+        const sub = fullArray.subarray(1, 4) // [20, 30, 40]
+        const regular = new Uint8Array([100, 200])
+        const result = ui8Concat([sub, regular])
+        expect(result).toBeInstanceOf(Uint8Array)
+        expect(ui8Equals(result, new Uint8Array([20, 30, 40, 100, 200]))).toBe(
+          true,
+        )
+      })
+    })
+  })
+}

package/src/uint8array-concat.ts

@@ -0,0 +1,21 @@
+import { NodeJSBuffer } from './lib/nodejs-buffer.js'
+
+const Buffer = NodeJSBuffer
+
+export const ui8ConcatNode = Buffer
+  ? function ui8ConcatNode(array: readonly Uint8Array[]): Uint8Array {
+      return Buffer.concat(array)
+    }
+  : /* v8 ignore next -- @preserve */ null
+
+export function ui8ConcatPonyfill(array: readonly Uint8Array[]): Uint8Array {
+  let totalLength = 0
+  for (const arr of array) totalLength += arr.length
+  const result = new Uint8Array(totalLength)
+  let offset = 0
+  for (const arr of array) {
+    result.set(arr, offset)
+    offset += arr.length
+  }
+  return result
+}

package/src/uint8array-from-base64.test.ts

@@ -1,6 +1,7 @@
 import 'core-js/modules/es.uint8-array.from-base64.js'
 import 'core-js/modules/es.uint8-array.to-base64.js'
-import assert from 'node:assert'
+
+import { assert, describe, expect, it } from 'vitest'
 import {
   fromBase64Native,
   fromBase64Node,
@@ -110,6 +111,8 @@ for (const fromBase64 of [
         'YWFh' + '====',
         'YWFh' + '=====',
         'YWFh' + '======',
+        'TWEé',
+        'TWE👍',
         // More invalid padding
         // 'TWE=', // 'Ma'
         'TWE=' + '=',

package/src/uint8array-from-base64.ts

@@ -45,7 +45,7 @@ export const fromBase64Node = Buffer
       // results in unexpected behavior downstream (e.g. in tests)
       return new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)
     }
-  : null
+  : /* v8 ignore next -- @preserve */ null
 
 export function fromBase64Ponyfill(
   b64: string,

package/src/uint8array-to-base64.test.ts

@@ -1,6 +1,6 @@
 import 'core-js/modules/es.uint8-array.from-base64.js'
 import 'core-js/modules/es.uint8-array.to-base64.js'
-import assert from 'node:assert'
+import { assert, describe, expect, it } from 'vitest'
 import {
   toBase64Native,
   toBase64Node,