Transform getLocale() and other APIs

Author: aomarks

README.md

@@ -59,7 +59,8 @@ In transform mode, calls to this function are replaced with `undefined`.
 Return a promise that is resolved when the next set of templates are loaded and
 available for rendering. Applications in runtime mode should always `await localeReady()` before rendering.
 
-In transform mode, calls to this function are replaced with `undefined`.
+In transform mode, calls to this function are replaced with
+`Promise.resolve(undefined)`.
 
 ### `msg(id: string, template, ...args): string|TemplateResult`
 

src/outputters/transform.ts

@@ -52,7 +52,7 @@ export function transformOutput(
     }
     opts.outDir = pathLib.join(outRoot, '/', locale);
     program.emit(undefined, undefined, undefined, undefined, {
-      before: [litLocalizeTransform(translations, program)],
+      before: [litLocalizeTransform(translations, locale, program)],
     });
   }
 }
@@ -62,10 +62,11 @@ export function transformOutput(
  */
 export function litLocalizeTransform(
   translations: Map<string, Message> | undefined,
+  locale: string,
   program: ts.Program
 ): ts.TransformerFactory<ts.SourceFile> {
   return (context) => {
-    const transformer = new Transformer(context, translations, program);
+    const transformer = new Transformer(context, translations, locale, program);
     return (file) => ts.visitNode(file, transformer.boundVisitNode);
   };
 }
@@ -76,26 +77,32 @@ export function litLocalizeTransform(
 class Transformer {
   private context: ts.TransformationContext;
   private translations: Map<string, Message> | undefined;
+  private locale: string;
   private typeChecker: ts.TypeChecker;
   boundVisitNode = this.visitNode.bind(this);
 
   constructor(
     context: ts.TransformationContext,
     translations: Map<string, Message> | undefined,
+    locale: string,
     program: ts.Program
   ) {
     this.context = context;
     this.translations = translations;
+    this.locale = locale;
     this.typeChecker = program.getTypeChecker();
   }
 
   /**
    * Top-level delegating visitor for all nodes.
    */
   visitNode(node: ts.Node): ts.VisitResult<ts.Node> {
+    // msg('greeting', 'hello') -> 'hola'
     if (isMsgCall(node, this.typeChecker)) {
       return this.replaceMsgCall(node);
     }
+
+    // html`<b>${msg('greeting', 'hello')}</b>` -> html`<b>hola</b>`
     if (isLitExpression(node)) {
       // If an html-tagged template literal embeds a msg call, we want to
       // collapse the result of that msg call into the parent template.
@@ -105,9 +112,38 @@ class Transformer {
         )
       );
     }
+
+    // import ... from 'lit-localize' -> (removed)
     if (this.isLitLocalizeImport(node)) {
       return undefined;
     }
+
+    // configureLocalization(...) -> undefined
+    if (
+      this.isCallToTaggedFunction(node, '_LIT_LOCALIZE_CONFIGURE_LOCALIZATION_')
+    ) {
+      return ts.createIdentifier('undefined');
+    }
+
+    // getLocale() -> "es-419"
+    if (this.isCallToTaggedFunction(node, '_LIT_LOCALIZE_GET_LOCALE_')) {
+      return ts.createStringLiteral(this.locale);
+    }
+
+    // setLocale("es-419") -> undefined
+    if (this.isCallToTaggedFunction(node, '_LIT_LOCALIZE_SET_LOCALE_')) {
+      return ts.createIdentifier('undefined');
+    }
+
+    // localeReady() -> Promise.resolve(undefined)
+    if (this.isCallToTaggedFunction(node, '_LIT_LOCALIZE_LOCALE_READY_')) {
+      return ts.createCall(
+        ts.createPropertyAccess(ts.createIdentifier('Promise'), 'resolve'),
+        [],
+        [ts.createIdentifier('undefined')]
+      );
+    }
+
     return ts.visitEachChild(node, this.boundVisitNode, this.context);
   }
 
@@ -358,6 +394,22 @@ class Transformer {
     }
     return false;
   }
+
+  /**
+   * Return whether the given node is call to a function which is is "tagged"
+   * with the given special identifying property (e.g. "_LIT_LOCALIZE_MSG_").
+   */
+  isCallToTaggedFunction(
+    node: ts.Node,
+    tagProperty: string
+  ): node is ts.CallExpression {
+    if (!ts.isCallExpression(node)) {
+      return false;
+    }
+    const type = this.typeChecker.getTypeAtLocation(node.expression);
+    const props = this.typeChecker.getPropertiesOfType(type);
+    return props.some((prop) => prop.escapedName === tagProperty);
+  }
 }
 
 /**

src/tests/transform.unit.test.ts

@@ -30,7 +30,8 @@ function checkTransform(
   inputTs: string,
   expectedJs: string,
   messages: Message[],
-  autoImport = true
+  autoImport = true,
+  locale = 'en'
 ) {
   if (autoImport) {
     // Rather than fuss with imports in all the test cases, this little hack
@@ -54,7 +55,7 @@ function checkTransform(
   // them here, so it's a waste of time.
   options.typeRoots = [];
   const result = compileTsFragment(inputTs, options, cache, (program) => ({
-    before: [litLocalizeTransform(makeMessageIdMap(messages), program)],
+    before: [litLocalizeTransform(makeMessageIdMap(messages), locale, program)],
   }));
 
   let formattedExpected = prettier.format(expectedJs, {parser: 'typescript'});
@@ -321,3 +322,62 @@ test('exclude different msg function', (t) => {
     false
   );
 });
+
+test('configureLocalization() -> undefined', (t) => {
+  checkTransform(
+    t,
+    `import {configureLocalization} from './lib_client/index.js';
+     configureLocalization({
+       sourceLocale: 'en',
+       targetLocales: ['es-419'],
+       loadLocale: (locale: string) => import(\`/\${locale}.js\`),
+     });`,
+    `undefined;`,
+    [],
+    true
+  );
+});
+
+test('getLocale() -> "es-419"', (t) => {
+  checkTransform(
+    t,
+    `import {getLocale} from './lib_client/index.js';
+     getLocale();`,
+    `"en";`,
+    [],
+    true,
+    'en'
+  );
+
+  checkTransform(
+    t,
+    `import {getLocale} from './lib_client/index.js';
+     getLocale();`,
+    `"es-419";`,
+    [],
+    true,
+    'es-419'
+  );
+});
+
+test('setLocale() -> undefined', (t) => {
+  checkTransform(
+    t,
+    `import {setLocale} from './lib_client/index.js';
+     setLocale("es-419");`,
+    `undefined;`,
+    [],
+    true
+  );
+});
+
+test('localeReady() -> Promise.resolve(undefined)', (t) => {
+  checkTransform(
+    t,
+    `import {localeReady} from './lib_client/index.js';
+     localeReady().then(() => console.log('ok'))`,
+    `Promise.resolve(undefined).then(() => console.log('ok'))`,
+    [],
+    true
+  );
+});

src_client/index.ts

@@ -93,26 +93,32 @@ let loading = new Deferred<void>();
  * Set runtime configuration parameters for lit-localize. This function must be
  * called before using any other lit-localize function.
  */
-export function configureLocalization(config: Configuration) {
+export const configureLocalization: ((config: Configuration) => void) & {
+  _LIT_LOCALIZE_CONFIGURE_LOCALIZATION_?: never;
+} = (config: Configuration) => {
   activeLocale = sourceLocale = config.sourceLocale;
   validLocales = new Set(config.targetLocales);
   validLocales.add(config.sourceLocale);
   loadLocale = config.loadLocale;
-}
+};
 
 /**
  * Return the active locale code. Returns empty string if lit-localize has not
  * yet been configured.
  */
-export function getLocale(): string {
+export const getLocale: (() => string) & {
+  _LIT_LOCALIZE_GET_LOCALE_?: never;
+} = () => {
   return activeLocale;
-}
+};
 
 /**
  * Set the active locale code, and begin loading templates for that locale using
  * the `loadLocale` function that was passed to `configureLocalization`.
  */
-export function setLocale(newLocale: string): void {
+export const setLocale: ((newLocale: string) => void) & {
+  _LIT_LOCALIZE_SET_LOCALE_?: never;
+} = (newLocale: string) => {
   if (
     newLocale === activeLocale ||
     !validLocales ||
@@ -147,15 +153,15 @@ export function setLocale(newLocale: string): void {
       }
     );
   }
-}
+};
 
 /**
  * Return a promise that is resolved when the next set of templates are loaded
  * and available for rendering.
  */
-export function localeReady(): Promise<void> {
-  return loading.promise;
-}
+export const localeReady: (() => Promise<void>) & {
+  _LIT_LOCALIZE_LOCALE_READY_?: never;
+} = () => loading.promise;
 
 /**
  * Make a string or lit-html template localizable.