Merge pull request #42 from PolymerLabs/transform-more

Transform configureTransformLocalization

Author: aomarks

README.md

@@ -21,11 +21,16 @@ The `lit-localize` module exports the following functions:
 Set configuration parameters for lit-localize when in runtime mode. Returns an
 object with functions:
 
-- [`getLocale`](#getLocale): Return the active locale code.
-- [`setLocale`](#setLocale): Set the active locale code.
+- [`getLocale`](#getlocale-string): Return the active locale code.
+- [`setLocale`](#setlocalelocale-string-promise): Set the active locale code.
 
 Throws if called more than once.
 
+When in transform mode, the lit-localize CLI will error if this function is
+called. Use
+[`configureTransformLocalization`](#configuretransformlocalizationconfiguration)
+instead.
+
 The `configuration` object must have the following properties:
 
 - `sourceLocale: string`: Required locale code in which source templates in this
@@ -52,12 +57,13 @@ const {getLocale, setLocale} = configureLocalization({
 ### `configureTransformLocalization(configuration)`
 
 Set configuration parameters for lit-localize when in transform mode. Returns an
-object with functions:
+object with function:
 
-- [`getLocale`](#getLocale): Return the active locale code.
+- [`getLocale`](#getlocale-string): Return the active locale code.
 
-(Note that [`setLocale`](#setLocale) is not available, because changing locales
-at runtime is not supported in transform mode.)
+(Note that [`setLocale`](#setlocalelocale-string-promise) is not available from
+this function, because changing locales at runtime is not supported in transform
+mode.)
 
 Throws if called more than once.
 
@@ -74,14 +80,19 @@ const {getLocale} = configureLocalization({
 });
 ```
 
+In transform mode, calls to this function are transformed to an object with a
+`getLocale` implementation that returns the static locale code for each locale
+bundle. For example:
+
+```typescript
+const {getLocale} = {getLocale: () => 'es-419'};
+```
+
 ### `getLocale(): string`
 
 Return the active locale code.
 
-In transform mode, calls to this function are transformed into the static locale
-code string for each emitted locale.
-
-### `setLocale(locale: string)`
+### `setLocale(locale: string): Promise`
 
 Set the active locale code, and begin loading templates for that locale using
 the `loadLocale` function that was passed to `configureLocalization`. Returns a

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 (isLitTemplate(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,49 @@ class Transformer {
         )
       );
     }
+
+    // import ... from 'lit-localize' -> (removed)
     if (this.isLitLocalizeImport(node)) {
       return undefined;
     }
+
+    // configureTransformLocalization(...) -> {getLocale: () => "es-419"}
+    if (
+      this.isCallToTaggedFunction(
+        node,
+        '_LIT_LOCALIZE_CONFIGURE_TRANSFORM_LOCALIZATION_'
+      )
+    ) {
+      return ts.createObjectLiteral(
+        [
+          ts.createPropertyAssignment(
+            ts.createIdentifier('getLocale'),
+            ts.createArrowFunction(
+              undefined,
+              undefined,
+              [],
+              undefined,
+              ts.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+              ts.createStringLiteral(this.locale)
+            )
+          ),
+        ],
+        false
+      );
+    }
+
+    // configureLocalization(...) -> Error
+    if (
+      this.isCallToTaggedFunction(node, '_LIT_LOCALIZE_CONFIGURE_LOCALIZATION_')
+    ) {
+      // TODO(aomarks) This error is not surfaced earlier in the analysis phase
+      // as a nicely formatted diagnostic, but it should be.
+      throw new KnownError(
+        'Cannot use configureLocalization in transform mode. ' +
+          'Use configureTransformLocalization instead.'
+      );
+    }
+
     return ts.visitEachChild(node, this.boundVisitNode, this.context);
   }
 
@@ -357,6 +404,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

@@ -32,6 +32,7 @@ function checkTransform(
   opts?: {
     messages?: Message[];
     autoImport?: boolean;
+    locale?: string;
   }
 ) {
   if (opts?.autoImport ?? true) {
@@ -57,7 +58,11 @@ function checkTransform(
   options.typeRoots = [];
   const result = compileTsFragment(inputTs, options, cache, (program) => ({
     before: [
-      litLocalizeTransform(makeMessageIdMap(opts?.messages ?? []), program),
+      litLocalizeTransform(
+        makeMessageIdMap(opts?.messages ?? []),
+        opts?.locale ?? 'en',
+        program
+      ),
     ],
   }));
 
@@ -328,3 +333,35 @@ test('exclude different msg function', (t) => {
     {autoImport: false}
   );
 });
+
+test('configureTransformLocalization() -> {getLocale: () => "es-419"}', (t) => {
+  checkTransform(
+    t,
+    `import {configureTransformLocalization} from './lib_client/index.js';
+     const {getLocale} = configureTransformLocalization({
+       sourceLocale: 'en',
+     });
+     const locale = getLocale();`,
+    `const {getLocale} = {getLocale: () => 'es-419'};
+     const locale = getLocale();`,
+    {locale: 'es-419'}
+  );
+});
+
+test('configureLocalization() throws', (t) => {
+  t.throws(
+    () =>
+      checkTransform(
+        t,
+        `import {configureLocalization} from './lib_client/index.js';
+     configureLocalization({
+       sourceLocale: 'en',
+       targetLocales: ['es-419'],
+       loadLocale: (locale: string) => import(\`/\${locale}.js\`),
+     });`,
+        `undefined;`
+      ),
+    undefined,
+    'Cannot use configureLocalization in transform mode'
+  );
+});

src_client/index.ts

@@ -111,7 +111,11 @@ let loading = new Deferred<void>();
  *
  * Throws if called more than once.
  */
-export function configureLocalization(config: RuntimeConfiguration) {
+export const configureLocalization: ((
+  config: RuntimeConfiguration
+) => {getLocale: typeof getLocale; setLocale: typeof setLocale}) & {
+  _LIT_LOCALIZE_CONFIGURE_LOCALIZATION_?: never;
+} = (config: RuntimeConfiguration) => {
   if (configured === true) {
     throw new Error('lit-localize can only be configured once');
   }
@@ -121,7 +125,7 @@ export function configureLocalization(config: RuntimeConfiguration) {
   validLocales.add(config.sourceLocale);
   loadLocale = config.loadLocale;
   return {getLocale, setLocale};
-}
+};
 
 /**
  * Set configuration parameters for lit-localize when in transform mode. Returns
@@ -131,21 +135,27 @@ export function configureLocalization(config: RuntimeConfiguration) {
  *
  * Throws if called more than once.
  */
-export function configureTransformLocalization(config: TransformConfiguration) {
+export const configureTransformLocalization: ((
+  config: TransformConfiguration
+) => {getLocale: typeof getLocale}) & {
+  _LIT_LOCALIZE_CONFIGURE_TRANSFORM_LOCALIZATION_?: never;
+} = (config: TransformConfiguration) => {
   if (configured === true) {
     throw new Error('lit-localize can only be configured once');
   }
   configured = true;
   activeLocale = sourceLocale = config.sourceLocale;
   return {getLocale};
-}
+};
 
 /**
  * Return the active locale code.
  */
-function getLocale(): string {
+const getLocale: (() => string) & {
+  _LIT_LOCALIZE_GET_LOCALE_?: never;
+} = () => {
   return activeLocale;
-}
+};
 
 /**
  * Set the active locale code, and begin loading templates for that locale using
@@ -161,7 +171,9 @@ function getLocale(): string {
  * Throws if the given locale is not contained by the configured `sourceLocale`
  * or `targetLocales`.
  */
-function setLocale(newLocale: string): Promise<void> {
+const setLocale: ((newLocale: string) => void) & {
+  _LIT_LOCALIZE_SET_LOCALE_?: never;
+} = (newLocale: string) => {
   if (!configured || !validLocales || !loadLocale) {
     throw new Error('Must call configureLocalization before setLocale');
   }
@@ -202,7 +214,7 @@ function setLocale(newLocale: string): Promise<void> {
     );
   }
   return loading.promise;
-}
+};
 
 /**
  * Make a string or lit-html template localizable.

testdata/transform/goldens/foo.ts

@@ -1,5 +1,11 @@
 import {html} from 'lit-html';
-import {msg} from '../../../lib_client/index.js';
+import {
+  msg,
+  configureTransformLocalization,
+} from '../../../lib_client/index.js';
+
+const {getLocale} = configureTransformLocalization({sourceLocale: 'en'});
+console.log(`Locale is ${getLocale()}`);
 
 msg('string', 'Hello World!');
 

testdata/transform/goldens/tsout/en/foo.js

@@ -1,4 +1,6 @@
 import {html} from 'lit-html';
+const {getLocale} = {getLocale: () => 'en'};
+console.log(`Locale is ${getLocale()}`);
 ('Hello World!');
 html`Hello <b><i>World!</i></b>`;
 `Hello World!`;

testdata/transform/goldens/tsout/es-419/foo.js

@@ -1,4 +1,6 @@
 import {html} from 'lit-html';
+const {getLocale} = {getLocale: () => 'es-419'};
+console.log(`Locale is ${getLocale()}`);
 `Hola Mundo!`;
 html`Hola <b><i>Mundo!</i></b>`;
 `Hola World!`;

testdata/transform/goldens/tsout/zh_CN/foo.js

@@ -1,4 +1,6 @@
 import {html} from 'lit-html';
+const {getLocale} = {getLocale: () => 'zh_CN'};
+console.log(`Locale is ${getLocale()}`);
 `\u4F60\u597D\uFF0C\u4E16\u754C\uFF01`;
 html`你好, <b><i>世界!</i></b>`;
 `Hello World!`;

testdata/transform/input/foo.ts

@@ -1,5 +1,11 @@
 import {html} from 'lit-html';
-import {msg} from '../../../lib_client/index.js';
+import {
+  msg,
+  configureTransformLocalization,
+} from '../../../lib_client/index.js';
+
+const {getLocale} = configureTransformLocalization({sourceLocale: 'en'});
+console.log(`Locale is ${getLocale()}`);
 
 msg('string', 'Hello World!');