@difizen/libro-common 0.3.4 → 1.0.0

package/src/ioc/register.ts

@@ -0,0 +1,210 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import type { interfaces } from 'inversify';
+
+import { ContainerAPI } from './container-api';
+import { Utils, Syringe } from './core';
+import type { InversifyContext } from './inversify-api';
+import { isInversifyContext } from './inversify-api';
+import {
+  bindNamed,
+  bindGeneralToken,
+  bindMonoToken,
+  bindLifecycle,
+} from './inversify-api';
+import { OptionSymbol } from './side-option';
+
+export class Register<T> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static globalConfig: Syringe.InjectOption<any> = Syringe.DefaultOption;
+  /**
+   * 注册目标 token，合并 token 配置后基于配置注册
+   */
+  static resolveTarget<R>(
+    ictx: InversifyContext,
+    target: Syringe.Token<R>,
+    option: Syringe.TargetOption<R> = {},
+  ): void {
+    try {
+      try {
+        const sideOption = Reflect.getMetadata(OptionSymbol, target);
+        if (sideOption) {
+          Register.resolveOption(ictx, sideOption);
+        }
+      } catch (ex) {
+        // noop
+      }
+      // 当 target 为类时，将其插入 useClass 配置中
+      if (Utils.isClass(target)) {
+        if (!option.useClass) {
+          option.useClass = [target];
+        } else {
+          const classes = Utils.toArray(option.useClass);
+          classes.unshift(target);
+          option.useClass = classes;
+        }
+      }
+      let mixedOption;
+      try {
+        mixedOption = Reflect.getMetadata(Syringe.ClassOptionSymbol, target);
+      } catch (ex) {
+        // noop
+      }
+      mixedOption = {
+        ...(mixedOption || {}),
+        ...option,
+      };
+      if (!mixedOption.token) {
+        mixedOption.token = [target];
+      } else {
+        const tokens = Utils.toArray(mixedOption.token);
+        tokens.unshift(target);
+        mixedOption.token = tokens;
+      }
+      Register.resolveOption(ictx, mixedOption);
+    } catch (ex) {
+      // noop
+    }
+  }
+  /**
+   * 基于配置注册
+   */
+  static resolveOption<R>(
+    ictx: InversifyContext,
+    baseOption: Syringe.InjectOption<R>,
+  ): void {
+    const parsedOption = Utils.toRegistryOption({
+      ...Register.globalConfig,
+      ...baseOption,
+    });
+    if (
+      parsedOption.useClass.length === 0 &&
+      parsedOption.useDynamic.length === 0 &&
+      parsedOption.useFactory.length === 0 &&
+      !('useValue' in parsedOption)
+    ) {
+      return;
+    }
+
+    parsedOption.token.forEach((token) => {
+      const register = new Register(ictx, token, { ...parsedOption });
+      register.resolve();
+    });
+  }
+
+  protected token: Syringe.UnionToken<T>;
+  protected rawToken: Syringe.Token<T>;
+  protected named?: Syringe.Named | undefined;
+  /**
+   * 兼容 inversify
+   */
+  protected generalToken: interfaces.ServiceIdentifier<T>;
+  protected option: Syringe.FormattedInjectOption<T>;
+  protected ictx: InversifyContext;
+  protected mutiple: boolean;
+  constructor(
+    ictx: InversifyContext,
+    token: Syringe.UnionToken<T>,
+    option: Syringe.FormattedInjectOption<T>,
+  ) {
+    this.ictx = ictx;
+    this.token = token;
+    this.option = option;
+    this.rawToken = Utils.isNamedToken(token) ? token.token : token;
+    this.named = Utils.isNamedToken(token) ? token.named : undefined;
+    this.mutiple = !!this.named || Utils.isMultipleEnabled(this.rawToken);
+    this.generalToken = this.rawToken;
+  }
+  /**
+   * multi or mono register
+   * priority: useValue > useDynamic > useFactory > useClass
+   */
+  resolve(): void {
+    const { ictx } = this;
+    if (!isInversifyContext(ictx)) {
+      return;
+    }
+    if (this.mutiple) {
+      this.resolveMutilple(ictx);
+    } else {
+      this.resolveMono(ictx);
+      if (!this.named && this.option.contrib.length > 0) {
+        this.option.contrib.forEach((contribution) => {
+          if (Utils.isMultipleEnabled(contribution)) {
+            bindGeneralToken(contribution, ictx).toService(this.generalToken);
+          } else {
+            bindMonoToken(contribution, ictx).toService(this.generalToken);
+          }
+        });
+      }
+    }
+  }
+  // eslint-disable-next-line consistent-return
+  protected resolveMono(
+    ictx: InversifyContext,
+  ): interfaces.BindingWhenOnSyntax<T> | undefined {
+    if ('useValue' in this.option) {
+      return bindMonoToken(this.generalToken, ictx).toConstantValue(
+        this.option.useValue!,
+      );
+    }
+    if (this.option.useDynamic.length > 0) {
+      const dynamic = this.option.useDynamic[this.option.useDynamic.length - 1];
+      return bindLifecycle(
+        bindMonoToken(this.generalToken, ictx).toDynamicValue((ctx) => {
+          const container = ContainerAPI.getOrCreateContainer(ctx.container)!;
+          return dynamic({ container });
+        }),
+        this.option,
+      );
+    }
+    if (this.option.useFactory.length > 0) {
+      const factrory = this.option.useFactory[this.option.useFactory.length - 1];
+      return bindMonoToken(this.generalToken, ictx).toFactory((ctx) => {
+        const container = ContainerAPI.getOrCreateContainer(ctx.container)!;
+        return factrory({ container });
+      });
+    }
+    if (this.option.useClass.length > 0) {
+      const newable = this.option.useClass[this.option.useClass.length - 1];
+      return bindLifecycle(
+        bindMonoToken(this.generalToken, ictx).to(newable),
+        this.option,
+      );
+    }
+    return undefined;
+  }
+  protected resolveMutilple(ictx: InversifyContext): void {
+    const classesList = this.option.useClass.map((newable) =>
+      bindLifecycle(bindGeneralToken(this.generalToken, ictx).to(newable), this.option),
+    );
+    const dynamicList = this.option.useDynamic.map((dynamic) =>
+      bindLifecycle(
+        bindGeneralToken(this.generalToken, ictx).toDynamicValue((ctx) => {
+          const container = ContainerAPI.getOrCreateContainer(ctx.container)!;
+          return dynamic({ container });
+        }),
+        this.option,
+      ),
+    );
+    const factoryList = this.option.useFactory.map((factrory) =>
+      bindGeneralToken(this.generalToken, ictx).toFactory((ctx) => {
+        const container = ContainerAPI.getOrCreateContainer(ctx.container)!;
+        return factrory({ container });
+      }),
+    );
+    const valueToBind =
+      'useValue' in this.option
+        ? bindGeneralToken(this.generalToken, ictx).toConstantValue(
+            this.option.useValue!,
+          )
+        : undefined;
+    if (this.named) {
+      classesList.forEach((tobind) => this.named && bindNamed(tobind, this.named));
+      dynamicList.forEach((tobind) => this.named && bindNamed(tobind, this.named));
+      factoryList.forEach((tobind) => this.named && bindNamed(tobind, this.named));
+      if (valueToBind) {
+        bindNamed(valueToBind, this.named);
+      }
+    }
+  }
+}

package/src/ioc/side-option.spec.ts

@@ -0,0 +1,39 @@
+import assert from 'assert';
+
+import { register, GlobalContainer } from './container';
+import { singleton } from './decorator';
+import { registerSideOption } from './side-option';
+
+describe('side option', () => {
+  it('#side register', () => {
+    const side = (target: any) => {
+      registerSideOption({ token: 'side', useValue: true }, target);
+    };
+    @side
+    @singleton()
+    class Foo {}
+    register(Foo);
+    const foo = GlobalContainer.get(Foo);
+    const sideValue = GlobalContainer.get<boolean>('side');
+    assert(foo instanceof Foo && sideValue === true);
+  });
+
+  it('#class extend side option', () => {
+    const side = (name: string) => {
+      return (target: any) => {
+        Reflect.defineMetadata('name', name, target);
+      };
+    };
+    @side('Foo')
+    @singleton()
+    class Foo {}
+    register(Foo);
+
+    @side('FooBar')
+    @singleton()
+    class FooBar extends Foo {}
+    register(FooBar);
+
+    assert(Reflect.getMetadata('name', FooBar) === 'FooBar');
+  });
+});

package/src/ioc/side-option.ts

@@ -0,0 +1,14 @@
+import type { Syringe } from './core';
+
+export const OptionSymbol = Symbol.for('SyringeSideOption');
+export const registerSideOption = <
+  T extends Record<any, any> = {
+    //
+  },
+  R = any,
+>(
+  option: Syringe.InjectOption<R>,
+  target: T,
+) => {
+  Reflect.defineMetadata(OptionSymbol, option, target);
+};

package/src/l10n/index.ts

@@ -0,0 +1,2 @@
+export * from './l10n';
+export * from './lang';

package/src/l10n/l10n/index.test.ts

@@ -0,0 +1,145 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import assert from 'assert';
+
+import { L10nLang, Localization } from '.';
+
+let l10n: Localization;
+
+describe('l10n', () => {
+  beforeEach(() => {
+    l10n = new Localization();
+    l10n.changeLang(L10nLang.enUS);
+  });
+
+  it('fallsback when no bundle', () => {
+    assert.strictEqual(l10n.t('message'), 'message');
+  });
+
+  it('load from contents', () => {
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        message: 'translated message',
+      },
+    });
+
+    assert.strictEqual(l10n.getLang(), L10nLang.enUS);
+
+    assert.strictEqual(l10n.t('message'), 'translated message');
+  });
+
+  it('supports index args', () => {
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        message: 'translated {0} message {1}',
+      },
+    });
+
+    assert.strictEqual(l10n.t('message', 'foo', 'bar'), 'translated foo message bar');
+  });
+
+  it('supports record args', () => {
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        message: 'translated {this} message {that}',
+      },
+    });
+
+    assert.strictEqual(
+      l10n.t('message', { this: 'foo', that: 'bar' }),
+      'translated foo message bar',
+    );
+  });
+
+  it('supports comments', () => {
+    const message = 'message';
+    const comment = 'This is a comment';
+    const result = 'translated message';
+
+    const key = `${message}/${comment}`;
+
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        [key]: { message: result, comment: [comment] },
+      },
+    });
+
+    // Normally we would be more static in the declaration of the object
+    // in order to extract them properly but for tests we don't need to do that.
+    assert.strictEqual(
+      l10n.t({
+        message,
+        comment: [comment],
+      }),
+      result,
+    );
+  });
+
+  it('supports index args and comments', () => {
+    const message = 'message {0}';
+    const comment = 'This is a comment';
+    const result = 'translated message foo';
+
+    const key = `${message}/${comment}`;
+
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        [key]: { message: 'translated message {0}', comment: [comment] },
+      },
+    });
+
+    // Normally we would be more static in the declaration of the object
+    // in order to extract them properly but for tests we don't need to do that.
+    assert.strictEqual(
+      l10n.t({
+        message,
+        comment: [comment],
+        args: ['foo'],
+      }),
+      result,
+    );
+  });
+
+  it('supports object args and comments', () => {
+    const message = 'message {this}';
+    const comment = 'This is a comment';
+    const result = 'translated message foo';
+
+    const key = `${message}/${comment}`;
+
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        [key]: { message: 'translated message {this}', comment: [comment] },
+      },
+    });
+
+    // Normally we would be more static in the declaration of the object
+    // in order to extract them properly but for tests we don't need to do that.
+    assert.strictEqual(
+      l10n.t({
+        message,
+        comment: [comment],
+        args: { this: 'foo' },
+      }),
+      result,
+    );
+  });
+
+  it('supports template literals', () => {
+    l10n.loadLang(L10nLang.enUS, {
+      contents: {
+        'original {0} message {1}': 'translated {0} message {1}',
+      },
+    });
+
+    const a = 'foo';
+    const b = 'bar';
+    assert.strictEqual(
+      l10n.t`original ${a} message ${b}`,
+      'translated foo message bar',
+    );
+  });
+});