feat: implement pseudo-locales and transformer functionality

Author: septs

src/pseudo-locale.ts

@@ -0,0 +1,40 @@
+/**
+ * Based on: https://hg-edge.mozilla.org/mozilla-central/file/a1f74e8c/intl/l10n/L10nRegistry.jsm#l425
+ */
+export class Transformer {
+  private readonly caps: readonly number[]
+  private readonly small: readonly number[]
+  private readonly elongate: boolean
+
+  constructor(caps: string, smalls: string, elongate: boolean) {
+    this.caps = Array.from(caps, (c) => c.codePointAt(0)!)
+    this.small = Array.from(smalls, (c) => c.codePointAt(0)!)
+    this.elongate = elongate
+    this.stringify = this.stringify.bind(this)
+    Object.freeze(this)
+  }
+
+  stringify(message: string) {
+    const points = Array.from(message, (c) => c.codePointAt(0)!)
+    return String.fromCodePoint.apply(null, Array.from(this.transform(points)))
+  }
+
+  private *transform(points: readonly number[]): Iterable<number> {
+    for (const point of points) {
+      if (point >= 0x61 && point <= 0x7a) {
+        yield this.small[point - 0x61] // a-z
+        if (!this.isElongate(point)) continue
+        yield this.small[point - 0x61] // duplicate "a", "e", "o" and "u" to emulate ~30% longer text
+      } else if (point >= 0x41 && point <= 0x5a) {
+        yield this.caps[point - 0x41] // A-Z
+      } else {
+        yield point // non-alphabetic characters remain unchanged
+      }
+    }
+  }
+
+  private isElongate(code: number): boolean {
+    if (!this.elongate) return false
+    return code === 0x61 || code === 0x65 || code === 0x6f || code === 0x75
+  }
+}

src/pseudo-locale/Transformer.ts

@@ -0,0 +1,44 @@
+import { createLiteralElement, isLiteralElement, MessageFormatElement } from '@formatjs/icu-messageformat-parser'
+import { Transformer } from './Transformer'
+
+export const ACCENTED_MAP = new Transformer(
+  '\u0226\u0181\u0187\u1e12\u1e16\u0191\u0193\u0126\u012a\u0134\u0136\u013f\u1e3e\u0220\u01fe\u01a4\u024a\u0158\u015e\u0166\u016c\u1e7c\u1e86\u1e8a\u1e8e\u1e90',
+  '\u0227\u0180\u0188\u1e13\u1e17\u0192\u0260\u0127\u012b\u0135\u0137\u0140\u1e3f\u019e\u01ff\u01a5\u024b\u0159\u015f\u0167\u016d\u1e7d\u1e87\u1e8b\u1e8f\u1e91',
+  true
+)
+
+export const FLIPPED_MAP = new Transformer(
+  '\u2200\u0510\u2183\u15e1\u018e\u2132\u2141\x48\x49\u017f\u04fc\u2142\x57\x4e\x4f\u0500\xd2\u1d1a\x53\u22a5\u2229\u0245\x4d\x58\u2144\x5a',
+  '\u0250\x71\u0254\x70\u01dd\u025f\u0183\u0265\u0131\u027e\u029e\u0285\u026f\x75\x6f\x64\x62\u0279\x73\u0287\x6e\u028c\u028d\x78\u028e\x7a',
+  false
+)
+
+export function createEnglishTransformer(brackets: string, transformer: Transformer) {
+  const [leftBracket, rightBracket] = brackets
+  return function* (elements: Iterable<MessageFormatElement>) {
+    yield createLiteralElement(leftBracket)
+    yield* modifyLiteralElement(elements, transformer.stringify)
+    yield createLiteralElement(rightBracket)
+  }
+}
+
+export function* modifyLiteralElement(
+  elements: Iterable<MessageFormatElement>,
+  modifier: (input: string) => string
+): Iterable<MessageFormatElement> {
+  for (const element of elements) {
+    if (isLiteralElement(element)) {
+      yield { ...element, value: modifier(element.value) }
+    } else if ('options' in element) {
+      const entries = Object.entries(element.options).map(([key, option]) => [
+        key,
+        { value: Array.from(modifyLiteralElement(option.value, modifier)) },
+      ])
+      yield { ...element, options: Object.fromEntries(entries) }
+    } else if ('children' in element) {
+      yield { ...element, children: Array.from(modifyLiteralElement(element.children, modifier)) }
+    } else {
+      yield element
+    }
+  }
+}

src/pseudo-locale/ast.ts

@@ -0,0 +1,26 @@
+import type { MessageFormatElement } from '@formatjs/icu-messageformat-parser'
+import { createLiteralElement } from '@formatjs/icu-messageformat-parser'
+import { ACCENTED_MAP, createEnglishTransformer, FLIPPED_MAP, modifyLiteralElement } from './ast'
+
+const locales: Record<string, (elements: Iterable<MessageFormatElement>) => Iterable<MessageFormatElement>> = {
+  *'xx-LS'(elements) {
+    yield* elements
+    yield createLiteralElement('S'.repeat(25))
+  },
+  'xx-AC': (elements) => modifyLiteralElement(elements, (value) => value.toUpperCase()),
+  *'xx-HA'(elements) {
+    yield createLiteralElement('[javascript]')
+    yield* elements
+  },
+  'en-XA': createEnglishTransformer('\u005b\u005d', ACCENTED_MAP),
+  'en-XB': createEnglishTransformer('\u202e\u202c', FLIPPED_MAP),
+}
+
+export function getPseudoLocaleNames(): string[] {
+  return Object.keys(locales)
+}
+
+export function getPseudoLocale(name: string): (elements: MessageFormatElement[]) => MessageFormatElement[] {
+  const handle = locales[name]
+  return (elements) => Array.from(handle(elements))
+}

src/pseudo-locale/index.ts

@@ -1,3 +1,5 @@
+import { MessageFormatElement } from '@formatjs/icu-messageformat-parser'
+import { printAST } from '@formatjs/icu-messageformat-parser/printer'
 import { createFsFromVolume, IFs, Volume } from 'memfs'
 import Module from 'node:module'
 import * as path from 'node:path'
@@ -38,8 +40,13 @@ export class WebpackCompiler {
     return this.fs.promises.readFile(path.join(this.basePath, name), 'utf-8') as Promise<string>
   }
 
-  async execute<T>() {
-    return execute<T>(await this.getEntryFile())
+  async execute(): Promise<Record<string, MessageFormatElement[]>> {
+    return execute(await this.getEntryFile())
+  }
+
+  async getMessages(): Promise<Record<string, string>> {
+    const messages = await this.execute()
+    return Object.fromEntries(Object.entries(messages).map(([key, value]) => [key, printAST(value)]))
   }
 }
 

tests/helpers.ts

@@ -51,14 +51,22 @@ describe('Webpack', () => {
   })
 
   describe('Pseudo-Locales', async () => {
-    const variants: readonly string[] = ['xx-LS', 'xx-AC', 'xx-HA', 'en-XA', 'en-XB']
+    const variants = new Map<string, Record<string, string>>([
+      ['xx-LS', { hello: 'worldSSSSSSSSSSSSSSSSSSSSSSSSS', tag: '<i>hello world</i>SSSSSSSSSSSSSSSSSSSSSSSSS' }],
+      ['xx-AC', { hello: 'WORLD', tag: '<i>HELLO WORLD</i>' }],
+      ['xx-HA', { hello: '[javascript]world', tag: '[javascript]<i>hello world</i>' }],
+      ['en-XA', { hello: '[ẇǿǿřŀḓ]', tag: '[<i>ħḗḗŀŀǿǿ ẇǿǿřŀḓ</i>]' }],
+      ['en-XB', { hello: '\u202eʍoɹʅp\u202c', tag: '\u202e<i>ɥǝʅʅo ʍoɹʅp</i>\u202c' }],
+    ])
 
-    for (const pseudoLocale of variants) {
+    for (const [pseudoLocale, expexted] of variants.entries()) {
       it(pseudoLocale, async () => {
         const instance = new WebpackCompiler('messages.default.json', { pseudoLocale })
         const { compilation } = await instance.run()
         expect(compilation.errors).lengthOf(0)
         expect(compilation.warnings).lengthOf(0)
+        const messages = await instance.getMessages()
+        expect(messages).deep.equals(expexted)
       })
     }