@tolgee/core 4.9.2 → 4.9.3-rc.04b22e6.0

package/lib/types.d.ts

@@ -1,84 +1,210 @@
-export interface TextInputElementData {
-    oldValue: string;
-    valueInputs: string[];
-    touched: boolean;
-    oldPlaceholder: string;
-    placeholderInputs: string[];
-}
-export declare type TreeTranslationsData = {
-    [key: string]: string | TreeTranslationsData;
-};
-export declare type Translations = Record<string, string>;
-export declare type TranslationParams = {
-    [key: string]: string | number | bigint;
-};
-export declare type TranslationParamsTags<T> = {
-    [key: string]: string | number | bigint | ((value: T | T[]) => T);
-};
-export declare type TranslateProps = {
-    key: string;
-    defaultValue?: string;
-    params?: TranslationParams;
+import type { Options } from './Controller/State/initState';
+import type { ObserverOptions } from './Controller/State/initObserverOptions';
+export type { State, Options } from './Controller/State/initState';
+export type { ObserverOptions, ModifierKey, } from './Controller/State/initObserverOptions';
+export type { EventEmitterInstance } from './Controller/Events/EventEmitter';
+export type { EventEmitterSelectiveInstance } from './Controller/Events/EventEmitterSelective';
+export declare type FallbackGeneral = undefined | false | string | string[];
+export declare type FallbackNS = FallbackGeneral;
+export declare type NsType = string;
+export declare type KeyType = string;
+export declare type FallbackNSTranslation = undefined | NsType | NsType[];
+export declare type FallbackLanguage = FallbackGeneral;
+export declare type FallbackLanguageObject = Record<string, FallbackLanguage>;
+export declare type FallbackLanguageOption = FallbackLanguage | FallbackLanguageObject;
+export declare type TranslateOptions<T> = {
+    ns?: FallbackNSTranslation;
     noWrap?: boolean;
     orEmpty?: boolean;
+    params?: TranslateParams<T>;
 };
-export declare type TranslatePropsTags<T> = {
-    key: string;
+export declare type TranslateProps<T = DefaultParamType> = {
+    key: KeyType;
     defaultValue?: string;
-    params?: TranslationParamsTags<T>;
-    noWrap?: boolean;
-    orEmpty?: boolean;
+} & TranslateOptions<T>;
+export declare type TranslatePropsInternal = TranslateProps & {
+    translation?: string;
 };
-export declare type InstantProps = {
-    key: string;
-    defaultValue?: string;
-    params?: TranslationParams;
-    noWrap?: boolean;
-    orEmpty?: boolean;
+export declare type TranslationValue = string | undefined | null;
+export declare type TranslationsFlat = Map<string, TranslationValue>;
+export declare type TreeTranslationsData = {
+    [key: string]: TranslationValue | TreeTranslationsData;
 };
-export declare type InstantPropsTags<T> = {
-    key: string;
-    defaultValue?: string;
-    params?: TranslationParamsTags<T>;
-    noWrap?: boolean;
-    orEmpty?: boolean;
+export declare type CacheAsyncRequests = Map<string, Promise<TreeTranslationsData | undefined> | undefined>;
+export declare type CacheDescriptor = {
+    language: string;
+    namespace?: string;
+};
+export declare type CacheDescriptorInternal = {
+    language: string;
+    namespace: string;
+};
+export declare type CacheDescriptorWithKey = CacheDescriptorInternal & {
+    key?: string;
 };
 export declare type KeyAndParams = {
     key: string;
-    params: TranslationParams;
+    params?: TranslateParams;
     defaultValue?: string;
+    ns?: FallbackNSTranslation;
 };
-export declare type KeyAndParamsTags<T> = {
-    key: string;
-    params: TranslationParamsTags<T>;
-    defaultValue?: string;
+export declare type Unwrapped = {
+    text: string;
+    keys: KeyAndParams[];
 };
-export declare type TranslatedWithMetadata = {
-    translated: string;
-    key: string;
-    params: TranslationParams;
-    defaultValue: string | undefined;
+declare type PropType<TObj> = TObj[keyof TObj];
+export declare type DefaultParamType = string | number | bigint;
+export declare type TranslateParams<T = DefaultParamType> = {
+    [key: string]: T;
 };
-export declare type TranslatedWithMetadataTags<T> = {
-    translated: TranslationTags<T>;
-    key: string;
-    params: TranslationParamsTags<T>;
-    defaultValue: string | undefined;
+export declare type CombinedOptions<T> = TranslateOptions<T> & {
+    [key: string]: T | PropType<TranslateOptions<T>>;
+};
+export declare type TFnType<T = DefaultParamType, R = string> = {
+    (key: string, defaultValue?: string, options?: CombinedOptions<T>): R;
+    (key: string, options?: CombinedOptions<T>): R;
+    (props: TranslateProps<T>): R;
+};
+export declare type WrapperWrapProps = Pick<TranslatePropsInternal, 'key' | 'params' | 'defaultValue' | 'ns' | 'translation'>;
+export declare type WrapperWrapFunction = (props: WrapperWrapProps) => string;
+export declare type WrapperUnwrapFunction = (text: string) => Unwrapped;
+export declare type WrapperAttributeXPathGetter = (props: {
+    tag: string;
+    attribute: string;
+}) => string;
+export declare type WrapperInterface = {
+    unwrap: WrapperUnwrapFunction;
+    wrap: WrapperWrapFunction;
+    getTextXPath: () => string;
+    getAttributeXPath: WrapperAttributeXPathGetter;
+};
+export declare type FormatterInterfaceFormatParams = {
+    translation: string;
+    language: string;
+    params: Record<string, any> | undefined;
+};
+export declare type FormatterInterface = {
+    format: (props: FormatterInterfaceFormatParams) => string;
 };
-export declare type TranslationTags<T> = string | T[];
-export declare type NodeWithMeta = Node & {
-    _tolgee: NodeMeta;
+export declare type FinalFormatterInterface = {
+    format: (props: FormatterInterfaceFormatParams) => any;
 };
-export declare type NodeWithLock = Node & {
-    _tolgee: NodeLock;
+export declare type ObserverProps = {
+    translate: (params: TranslatePropsInternal) => string;
+    onClick: TranslationOnClick;
+    options: ObserverOptions;
 };
-export declare type ElementWithMeta = Element & ElementCSSInlineStyle & {
-    _tolgee: ElementMeta;
+export declare type HighlightInterface = (key?: string, ns?: FallbackNSTranslation) => {
+    unhighlight(): void;
+};
+export declare type ObserverRunProps = {
+    mouseHighlight: boolean;
+};
+export declare type ObserverInterface = (props: ObserverProps) => {
+    unwrap: (text: string) => Unwrapped;
+    wrap: WrapperWrapFunction;
+    retranslate: () => void;
+    stop: () => void;
+    run: (props: ObserverRunProps) => void;
+    highlight: HighlightInterface;
+    outputNotFormattable: boolean;
+};
+export declare type LanguageDetectorProps = {
+    availableLanguages: string[];
+};
+export declare type LanguageDetectorInterface = {
+    getLanguage: (props: LanguageDetectorProps) => string | undefined | Promise<string | undefined>;
+};
+export declare type LanguageStorageInterface = {
+    getLanguage: () => string | undefined | Promise<string | undefined>;
+    setLanguage: (language: string) => void | Promise<void>;
+};
+export declare type DevCredentials = undefined | {
+    apiUrl?: string;
+    apiKey?: string;
+};
+export declare type BackendDevProps = {
+    apiUrl?: string;
+    apiKey?: string;
+    projectId?: number;
+};
+export declare type BackendGetRecordProps = {
+    language: string;
+    namespace?: string;
+};
+export declare type BackendGetRecord = (data: BackendGetRecordProps) => Promise<TreeTranslationsData | undefined> | undefined;
+export interface BackendInterface {
+    getRecord: BackendGetRecord;
+}
+export declare type BackendGetDevRecord = (data: BackendGetRecordProps & BackendDevProps) => Promise<TreeTranslationsData | undefined> | undefined;
+export declare type BackendDevInterface = {
+    getRecord: BackendGetDevRecord;
+};
+export declare type TolgeeEvent = 'pendingLanguage' | 'language' | 'key' | 'loading' | 'fetching' | 'initialLoad' | 'running' | 'cache' | 'keyUpdate';
+export declare type TolgeeOn = {
+    (event: 'pendingLanguage', handler: ListenerHandler<string>): Listener;
+    (event: 'language', handler: ListenerHandler<string>): Listener;
+    (event: 'key', handler: ListenerHandler<string>): Listener;
+    (event: 'loading', handler: ListenerHandler<boolean>): Listener;
+    (event: 'fetching', handler: ListenerHandler<boolean>): Listener;
+    (event: 'initialLoad', handler: ListenerHandler<void>): Listener;
+    (event: 'running', handler: ListenerHandler<boolean>): Listener;
+    (event: 'keyUpdate', handler: ListenerHandler<void>): Listener;
+    (event: TolgeeEvent, handler: ListenerHandler<any>): Listener;
+};
+export declare type TolgeeInstance = Readonly<{
+    on: TolgeeOn;
+    onKeyUpdate: (handler: ListenerHandler<void>) => ListenerSelective;
+    use: (plugin: TolgeePlugin | undefined) => TolgeeInstance;
+    getLanguage: () => string | undefined;
+    getPendingLanguage: () => string | undefined;
+    changeLanguage: (language: string) => Promise<void>;
+    changeTranslation: ChangeTranslationInterface;
+    addActiveNs: (ns: FallbackNSTranslation, forget?: boolean) => Promise<void>;
+    removeActiveNs: (ns: FallbackNSTranslation) => void;
+    loadRecords: (descriptors: CacheDescriptor[]) => Promise<TranslationsFlat[]>;
+    loadRecord: (descriptors: CacheDescriptor) => Promise<TranslationsFlat>;
+    addStaticData: (data: Options['staticData']) => void;
+    getRecord: (descriptor: CacheDescriptor) => TranslationsFlat | undefined;
+    getAllRecords: () => CachePublicRecord[];
+    isInitialLoading: () => boolean;
+    isLoading: (ns?: FallbackNSTranslation) => boolean;
+    isLoaded: (ns?: FallbackNSTranslation) => boolean;
+    isFetching: (ns?: FallbackNSTranslation) => boolean;
+    isRunning: () => boolean;
+    highlight: HighlightInterface;
+    getInitialOptions: () => Options;
+    isDev: () => boolean;
+    init: (options: Partial<Options>) => TolgeeInstance;
+    run: () => Promise<void>;
+    stop: () => void;
+    t: TFnType;
+    wrap: (params: TranslatePropsInternal) => string | undefined;
+    unwrap: (text: string) => Unwrapped;
+    setObserverOptions: (options: Partial<ObserverOptions>) => TolgeeInstance;
+}>;
+export declare type PluginServicePublic = Readonly<{
+    setFinalFormatter: (formatter: FinalFormatterInterface | undefined) => void;
+    addFormatter: (formatter: FormatterInterface | undefined) => void;
+    setObserver: (observer: ObserverInterface | undefined) => void;
+    hasObserver: () => boolean;
+    setUi: (ui: UiLibInterface | undefined) => void;
+    hasUi: () => boolean;
+    addBackend: (backend: BackendInterface | undefined) => void;
+    setDevBackend: (backend: BackendInterface | undefined) => void;
+    setLanguageDetector: (languageDetector: LanguageDetectorInterface | undefined) => void;
+    setLanguageStorage: (languageStorage: LanguageStorageInterface | undefined) => void;
+    overrideCredentials: (credentials: DevCredentials) => void;
+}>;
+export declare type NodeMeta = {
+    oldTextContent: string;
+    keys: KeyAndParams[];
+    keyAttributeOnly?: boolean;
 };
 export declare type ElementMeta = {
     wrappedWithElementOnlyKey?: string;
     wrappedWithElementOnlyDefaultHtml?: string;
-    nodes: Set<NodeWithMeta>;
+    nodes: Map<Node, NodeMeta>;
     highlightEl?: HTMLDivElement;
     highlight?: () => void;
     unhighlight?: () => void;
@@ -94,30 +220,64 @@ export declare type ElementMeta = {
      */
     preventClean?: boolean;
 };
-export declare type NodeMeta = {
-    oldTextContent: string;
-    keys: KeyAndParamsTags<any>[];
-} & NodeLock;
-export declare type NodeLock = {
-    locked?: boolean;
+export declare type ChangeTranslationInterface = (descriptor: CacheDescriptor, key: string, value: string) => {
+    revert: () => void;
 };
-export declare type Scope = 'translations.edit' | 'translations.view' | 'keys.edit' | 'screenshots.upload' | 'screenshots.view' | 'screenshots.delete';
-export declare type Mode = 'development' | 'production';
-export declare type Unwrapped = {
-    text: string;
-    keys: KeyAndParamsTags<any>[];
+export declare type UiProps = {
+    apiUrl: string;
+    apiKey: string;
+    highlight: HighlightInterface;
+    changeTranslation: ChangeTranslationInterface;
 };
-export interface Formatter {
-    format: FormatFunction;
-}
-interface FormatterStatic {
-    type: 'formatter';
-    new (): Formatter;
+export interface UiInterface {
+    handleElementClick(event: MouseEvent, keysAndDefaults: UiKeyOption[]): Promise<void>;
 }
-export declare type TolgeeModule = FormatterStatic;
-export declare type FormatFunction = (props: {
-    translation: string;
-    params: Record<string, any>;
+export declare type UiConstructor = new (props: UiProps) => UiInterface;
+export declare type UiLibInterface = {
+    UI: UiConstructor;
+};
+export declare type UiType = UiConstructor | UiLibInterface;
+export declare type UiKeyOption = {
+    key: string;
+    defaultValue?: string;
+    ns: FallbackNSTranslation;
+    translation: string | undefined;
+};
+export declare type KeyWithDefault = {
+    key: string;
+    defaultValue?: string;
+    ns: FallbackNSTranslation;
+};
+export declare type TranslationOnClick = (event: MouseEvent, data: {
+    keysAndDefaults: KeyWithDefault[];
+    el: Element;
+    meta: ElementMeta;
+}) => void;
+export declare type Listener = {
+    unsubscribe: () => void;
+};
+export declare type KeyDescriptorInternal = {
+    key?: string;
+    ns?: string[] | undefined;
+};
+export declare type KeyDescriptor = {
+    key: string;
+    ns?: string | string[];
+};
+export declare type ListenerSelective = {
+    unsubscribe: () => void;
+    subscribeNs: (ns: FallbackNSTranslation) => ListenerSelective;
+    unsubscribeNs: (ns: FallbackNSTranslation) => ListenerSelective;
+    subscribeKey: (descriptor: KeyDescriptor) => ListenerSelective;
+    unsubscribeKey: (descriptor: KeyDescriptor) => ListenerSelective;
+};
+export declare type ListenerHandlerEvent<T> = {
+    value: T;
+};
+export declare type ListenerHandler<T> = (e: ListenerHandlerEvent<T>) => void;
+export declare type TolgeePlugin = (tolgee: TolgeeInstance, tools: PluginServicePublic) => TolgeeInstance;
+export declare type CachePublicRecord = {
+    data: TranslationsFlat;
     language: string;
-}) => string | any[];
-export {};
+    namespace: string;
+};

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@tolgee/core",
-  "version": "4.9.2",
+  "version": "4.9.3-rc.04b22e6.0",
   "description": "Library providing ability to translate messages directly in context of developed application.",
-  "main": "index.js",
-  "module": "./dist/tolgee.esm.mjs",
+  "main": "./dist/tolgee.cjs.js",
+  "module": "./dist/tolgee.esm.js",
   "types": "./lib/index.d.ts",
   "repository": {
     "type": "git",
@@ -19,56 +19,48 @@
     "languages"
   ],
   "declaration": true,
+  "exports": {
+    "require": "./dist/tolgee.cjs.js",
+    "import": "./dist/tolgee.esm.js"
+  },
   "directories": {
     "lib": "lib",
     "dist": "dist"
   },
   "scripts": {
-    "build": "rollup -c rollup.config.js && tsc --project tsconfig.prod.json",
-    "clean": "rm -rf build build-e2e dist dist-e2e lib",
-    "test": "jest --config ./jest.config.js",
-    "develop": "concurrently \"rollup -c rollup.config.js -w\" \"tsc --watch --preserveWatchOutput --project tsconfig.prod.json\" ",
-    "schema": "openapi-typescript http://localhost:8080/v3/api-docs/All%20Internal%20-%20for%20Tolgee%20Web%20application --output ./src/types/apiSchema.generated.ts",
-    "typedoc": "typedoc --entryPointStrategy expand --out docs src/index.ts src/Tolgee.ts src/types.ts src/services/EventEmitter.ts  src/services/Subscription.ts",
-    "tsc": "tsc --noEmit --emitDeclarationOnly false"
+    "build": "rollup -c rollup.config.js && tsc --declaration --emitDeclarationOnly --project tsconfig.prod.json",
+    "clean": "rm -rf dist lib",
+    "test": "jest --collect-coverage",
+    "develop": "concurrently \"rollup -c rollup.config.js -w\" \"tsc --declaration --emitDeclarationOnly --watch --preserveWatchOutput --project tsconfig.prod.json\" ",
+    "tsc": "tsc --noEmit"
   },
-  "author": "JanCizmar",
+  "author": "Tolgee",
   "license": "MIT",
   "files": [
-    "index.js",
     "lib/**/*",
     "dist/**/*",
     "src/**/*"
   ],
   "devDependencies": {
     "@rollup/plugin-node-resolve": "13.3.0",
-    "@rollup/plugin-replace": "^4.0.0",
     "@rollup/plugin-typescript": "8.3.4",
-    "@testing-library/dom": "^8.7.1",
-    "@testing-library/jest-dom": "^5.11.4",
+    "@testing-library/jest-dom": "^5.16.5",
     "@types/jest": "^27.0.2",
     "@types/node": "^17.0.8",
     "@types/testing-library__jest-dom": "^5.14.5",
     "concurrently": "7.3.0",
     "intl-messageformat": "^9.9.1",
     "jest": "^27.2.4",
-    "jest-environment-jsdom": "^27.5.1",
     "jest-fetch-mock": "^3.0.3",
-    "openapi-typescript": "^4.3.0",
-    "rollup": "^2.78.1",
+    "rollup": "^2.56.3",
+    "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-terser": "7.0.2",
-    "ts-jest": "^27.0.5",
-    "tslib": "^2.4.0",
-    "typedoc": "0.22.15",
-    "typedoc-plugin-markdown": "3.13.2",
-    "typescript": "4.7.4"
+    "rollup-plugin-visualizer": "^5.8.0",
+    "ts-jest": "^27.1.5",
+    "typescript": "^4.7.4"
   },
-  "exports": {
-    "require": "./dist/tolgee.cjs.js",
-    "import": "./dist/tolgee.esm.mjs"
-  },
-  "gitHead": "dcbded7f7d158facb5eac126baf2ec1e1dc5699e",
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "gitHead": "5caa2e5f5a7920d75f5ed25fcb92cb41d249b449"
 }