@tolgee/core 4.9.2 → 4.9.3-rc.730f576.0

package/src/__test/namespacesFallback.test.ts

@@ -0,0 +1,74 @@
+import { Tolgee } from '../Tolgee';
+
+describe('namespaces fallback', () => {
+  test('works with multiple and default', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['first', 'second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('first');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works when no fallback specified', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['first', 'second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works when data present but no fallback', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['second'],
+    });
+
+    expect(tolgee.t({ key: '0' })).toEqual('noNamespace');
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '2' })).toEqual('second');
+    expect(tolgee.t({ key: '4' })).toEqual('4');
+    expect(tolgee.t({ key: '4', orEmpty: true })).toEqual('');
+  });
+
+  test('works with override', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: {
+        en: { '0': 'noNamespace' },
+        'en:first': { '1': 'first' },
+        'en:second': { '2': 'second' },
+      },
+      fallbackNs: ['second'],
+    });
+
+    expect(tolgee.t({ key: '1' })).toEqual('1');
+    expect(tolgee.t({ key: '1', ns: 'first' })).toEqual('first');
+    expect(tolgee.t({ key: '0', ns: 'first' })).toEqual('0');
+    expect(tolgee.t({ key: '2', ns: 'first' })).toEqual('2');
+    expect(tolgee.t({ key: '2', ns: 'second' })).toEqual('second');
+  });
+});

package/src/__test/plugins.test.ts

@@ -0,0 +1,136 @@
+import { Tolgee } from '../Tolgee';
+import {
+  FinalFormatterInterface,
+  FormatterInterface,
+  FormatterInterfaceFormatParams,
+  ObserverInterface,
+  TolgeePlugin,
+  WrapperWrapFunction,
+  ObserverOptions,
+} from '../types';
+
+const testObserver =
+  (
+    outputNotFormattable: boolean,
+    onCreate?: (options: ObserverOptions) => void
+  ): ObserverInterface =>
+  ({ options }) => {
+    const wrap: WrapperWrapFunction = ({ key, translation }) => {
+      return `${key}|${translation}`;
+    };
+    const unwrap = (input: string) => {
+      const [key, text] = input.split('|');
+      return { text, keys: [{ key }] };
+    };
+
+    const stop = () => {};
+    const run = () => {};
+
+    const retranslate = () => {};
+
+    onCreate?.(options);
+
+    return Object.freeze({
+      wrap,
+      unwrap,
+      run,
+      stop,
+      retranslate,
+      highlight: () => ({ unhighlight: () => {} }),
+      outputNotFormattable,
+    });
+  };
+
+const testFormatter1: FormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return `(1${translation})`;
+  },
+};
+
+const testFormatter2: FormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return `(2${translation})`;
+  },
+};
+
+const testFinalFormatter: FinalFormatterInterface = {
+  format: ({ translation }: FormatterInterfaceFormatParams) => {
+    return { final: translation };
+  },
+};
+
+const observerPlugin =
+  (
+    outputNotFormattable: boolean,
+    onCreate?: (options: ObserverOptions) => void
+  ): TolgeePlugin =>
+  (tolgee, tools) => {
+    tools.setObserver(testObserver(outputNotFormattable, onCreate));
+    return tolgee;
+  };
+
+const formattersPlugin: TolgeePlugin = (tolgee, tools) => {
+  tools.addFormatter(testFormatter1);
+  tools.addFormatter(testFormatter2);
+  tools.setFinalFormatter(testFinalFormatter);
+  return tolgee;
+};
+
+describe('plugins', () => {
+  it('wraps and formats translation', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(false));
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+
+    tolgee.use(formattersPlugin);
+    expect(tolgee.t({ key: 'hello' })).toEqual({ final: '(2(1hello|world))' });
+    tolgee.stop();
+  });
+
+  it("won't format when observer doesn't return formattable text", () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(true));
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+
+    tolgee.use(formattersPlugin);
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+    tolgee.stop();
+  });
+
+  it("won't wrap before run", () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    tolgee.use(observerPlugin(false));
+    expect(tolgee.t({ key: 'hello' })).toEqual('world');
+    tolgee.run();
+    expect(tolgee.t({ key: 'hello' })).toEqual('hello|world');
+  });
+
+  it('observer recieves options', () => {
+    const tolgee = Tolgee({
+      language: 'en',
+      staticData: { en: { hello: 'world' } },
+    });
+    const restrictedElements = ['test'];
+    tolgee.setObserverOptions({
+      restrictedElements,
+    });
+    const onCreate = jest.fn();
+    tolgee.use(observerPlugin(false, onCreate));
+    tolgee.run();
+    expect(onCreate).toBeCalledTimes(1);
+    expect(onCreate.mock.calls[0][0].restrictedElements).toEqual(
+      restrictedElements
+    );
+  });
+});

package/src/__test/testTools.ts

@@ -0,0 +1,7 @@
+export const resolvablePromise = <T = any>() => {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((innerResolve) => {
+    resolve = innerResolve;
+  });
+  return [promise, resolve!] as const;
+};

package/src/{Constants/Global.ts → constants.ts}

@@ -1,9 +1,7 @@
 export const RESTRICTED_ASCENDANT_ATTRIBUTE = 'data-tolgee-restricted';
-
 export const TOLGEE_ATTRIBUTE_NAME = '_tolgee';
-export const TOLGEE_TARGET_ATTRIBUTE = '_tolgee-target';
-export const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = 'data-tolgee-key-only';
 export const TOLGEE_HIGHLIGHTER_CLASS = '_tolgee-highlighter';
+export const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = 'data-tolgee-key-only';
 
 // needs to be same as in @tolgee/ui package
 export const DEVTOOLS_ID = '__tolgee_dev_tools';

package/src/helpers.ts

@@ -0,0 +1,17 @@
+export function isPromise(value: any) {
+  return Boolean(value && typeof value.then === 'function');
+}
+
+export const valueOrPromise = <T, R>(
+  value: T | Promise<T>,
+  callback: (value: T) => R
+) => {
+  if (isPromise(value)) {
+    return Promise.resolve(value).then(callback);
+  } else {
+    return callback(value as T);
+  }
+};
+
+export const missingOptionError = (option: string) =>
+  `Tolgee: You need to specify '${option}' option`;

package/src/index.ts

@@ -1,10 +1,11 @@
 export { Tolgee } from './Tolgee';
-export { TolgeeConfig } from './TolgeeConfig';
-export { ModifierKey } from './Constants/ModifierKey';
-export { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from './Constants/Global';
-export * from './modules';
-export * from './types/DTOs';
+export {
+  RESTRICTED_ASCENDANT_ATTRIBUTE,
+  DEVTOOLS_ID,
+  TOLGEE_ATTRIBUTE_NAME,
+  TOLGEE_HIGHLIGHTER_CLASS,
+  TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE,
+} from './constants';
 export * from './types';
-export * from './Constants/Global';
-export * from './helpers/NodeHelper';
-export * from './helpers/TextHelper';
+export { getTranslateParams } from './TranslateParams';
+export { getFallback, getFallbackArray } from './Controller/State/helpers';