@atproto/lex-data 0.0.5 → 0.0.7

package/src/utf8-grapheme-len.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'
 
-describe('graphemeLenSegmenter', () => {
+describe(graphemeLenNative!, () => {
   it('computes grapheme length', () => {
     expect(graphemeLenNative!('a')).toBe(1)
     expect(graphemeLenNative!('~')).toBe(1)
@@ -19,7 +19,7 @@ describe('graphemeLenSegmenter', () => {
   })
 })
 
-describe('graphemeLenInternal', () => {
+describe(graphemeLenPonyfill, () => {
   it('computes grapheme length', () => {
     expect(graphemeLenPonyfill('a')).toBe(1)
     expect(graphemeLenPonyfill('~')).toBe(1)

package/src/utf8-len.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { utf8LenCompute, utf8LenNode } from './utf8-len.js'
 
-describe('utf8LenNode', () => {
+describe(utf8LenNode!, () => {
   it('computes utf8 string length', () => {
     expect(utf8LenNode!('a')).toBe(1)
     expect(utf8LenNode!('~')).toBe(1)
@@ -16,7 +16,7 @@ describe('utf8LenNode', () => {
   })
 })
 
-describe('utf8LenInternal', () => {
+describe(utf8LenCompute, () => {
   it('computes utf8 string length', () => {
     expect(utf8LenCompute('a')).toBe(1)
     expect(utf8LenCompute('~')).toBe(1)

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

@@ -0,0 +1,35 @@
+import { assert, describe, expect, it } from 'vitest'
+import { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'
+
+const strings = [
+  'Hello, World!',
+  '¡Hola, Mundo!',
+  'こんにちは世界',
+  '😀👩‍💻🌍',
+  '',
+  '𓀀𓁐𓂀𓃰𓄿𓅱𓆑𓇋𓈖𓉔𓊃𓋴𓌳𓍿𓎛𓏏',
+]
+
+for (const utf8ToBase64 of [utf8ToBase64Node, utf8ToBase64Ponyfill] as const) {
+  assert(utf8ToBase64, 'implementation should not be null')
+
+  describe(utf8ToBase64, () => {
+    it('encodes utf8 string to base64', () => {
+      for (const text of strings) {
+        const b64 = Buffer.from(text, 'utf8')
+          .toString('base64')
+          .replaceAll('=', '') // utf8ToBase64 omits padding
+        const encoded = utf8ToBase64(text, 'base64')
+        expect(encoded).toBe(b64)
+      }
+    })
+
+    it('encodes utf8 string to base64url', () => {
+      for (const text of strings) {
+        const b64u = Buffer.from(text, 'utf8').toString('base64url')
+        const encoded = utf8ToBase64(text, 'base64url')
+        expect(encoded).toBe(b64u)
+      }
+    })
+  })
+}

package/src/utf8-to-base64.ts

@@ -0,0 +1,22 @@
+import { toString } from 'uint8arrays/to-string'
+import { NodeJSBuffer } from './lib/nodejs-buffer.js'
+import { Base64Alphabet } from './uint8array-base64.js'
+import { toBase64Node } from './uint8array-to-base64.js'
+
+const Buffer = NodeJSBuffer
+
+export const utf8ToBase64Node = Buffer
+  ? function utf8ToBase64Node(text: string, alphabet?: Base64Alphabet): string {
+      const buffer = Buffer.from(text, 'utf8')
+      return toBase64Node!(buffer, alphabet)
+    }
+  : /* v8 ignore next -- @preserve */ null
+
+const textEncoder = /*#__PURE__*/ new TextEncoder()
+export function utf8ToBase64Ponyfill(
+  text: string,
+  alphabet?: Base64Alphabet,
+): string {
+  const bytes = textEncoder.encode(text)
+  return toString(bytes, alphabet)
+}

package/src/utf8.ts

@@ -1,9 +1,17 @@
+import { Base64Alphabet } from './uint8array.js'
+import {
+  utf8FromBase64Node,
+  utf8FromBase64Ponyfill,
+} from './utf8-from-base64.js'
 import { graphemeLenNative, graphemeLenPonyfill } from './utf8-grapheme-len.js'
 import { utf8LenCompute, utf8LenNode } from './utf8-len.js'
+import { utf8ToBase64Node, utf8ToBase64Ponyfill } from './utf8-to-base64.js'
 
 export const graphemeLen: (str: string) => number =
-  graphemeLenNative ?? graphemeLenPonyfill
+  /* v8 ignore next -- @preserve */ graphemeLenNative ??
+  /* v8 ignore next -- @preserve */ graphemeLenPonyfill
 
+/* v8 ignore next -- @preserve */
 if (graphemeLen === graphemeLenPonyfill) {
   /*#__PURE__*/
   console.warn(
@@ -11,4 +19,17 @@ if (graphemeLen === graphemeLenPonyfill) {
   )
 }
 
-export const utf8Len: (string: string) => number = utf8LenNode ?? utf8LenCompute
+export const utf8Len: (string: string) => number =
+  /* v8 ignore next -- @preserve */ utf8LenNode ??
+  /* v8 ignore next -- @preserve */ utf8LenCompute
+
+export const utf8ToBase64: (str: string, alphabet?: Base64Alphabet) => string =
+  /* v8 ignore next -- @preserve */ utf8ToBase64Node ??
+  /* v8 ignore next -- @preserve */ utf8ToBase64Ponyfill
+
+export const utf8FromBase64: (
+  b64: string,
+  alphabet?: Base64Alphabet,
+) => string =
+  /* v8 ignore next -- @preserve */ utf8FromBase64Node ??
+  /* v8 ignore next -- @preserve */ utf8FromBase64Ponyfill