@tolgee/core 4.7.4-rc.1a63ba95.0 → 4.8.6

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+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;
+    noWrap?: boolean;
+    orEmpty?: boolean;
+};
+export declare type TranslatePropsTags<T> = {
+    key: string;
+    defaultValue?: string;
+    params?: TranslationParamsTags<T>;
+    noWrap?: boolean;
+    orEmpty?: boolean;
+};
+export declare type InstantProps = {
+    key: string;
+    defaultValue?: string;
+    params?: TranslationParams;
+    noWrap?: boolean;
+    orEmpty?: boolean;
+};
+export declare type InstantPropsTags<T> = {
+    key: string;
+    defaultValue?: string;
+    params?: TranslationParamsTags<T>;
+    noWrap?: boolean;
+    orEmpty?: boolean;
+};
+export declare type KeyAndParams = {
+    key: string;
+    params: TranslationParams;
+    defaultValue?: string;
+};
+export declare type KeyAndParamsTags<T> = {
+    key: string;
+    params: TranslationParamsTags<T>;
+    defaultValue?: string;
+};
+export declare type TranslatedWithMetadata = {
+    translated: string;
+    key: string;
+    params: TranslationParams;
+    defaultValue: string | undefined;
+};
+export declare type TranslatedWithMetadataTags<T> = {
+    translated: TranslationTags<T>;
+    key: string;
+    params: TranslationParamsTags<T>;
+    defaultValue: string | undefined;
+};
+export declare type TranslationTags<T> = string | T[];
+export declare type NodeWithMeta = Node & {
+    _tolgee: NodeMeta;
+};
+export declare type NodeWithLock = Node & {
+    _tolgee: NodeLock;
+};
+export declare type ElementWithMeta = Element & ElementCSSInlineStyle & {
+    _tolgee: ElementMeta;
+};
+export declare type ElementMeta = {
+    wrappedWithElementOnlyKey?: string;
+    wrappedWithElementOnlyDefaultHtml?: string;
+    nodes: Set<NodeWithMeta>;
+    highlightEl?: HTMLDivElement;
+    highlight?: () => void;
+    unhighlight?: () => void;
+    /**
+     * Stops removing of element's inactive nodes and
+     * unregistering from ElementRegistrar.
+     *
+     * It's used when user has mouse on the element, so there is
+     * potential, that element highlight will be triggered.
+     *
+     * Triggering highlight needs the metadata stored on element, so
+     * we need the ability to prevent clean.
+     */
+    preventClean?: boolean;
+};
+export declare type NodeMeta = {
+    oldTextContent: string;
+    keys: KeyAndParamsTags<any>[];
+} & NodeLock;
+export declare type NodeLock = {
+    locked?: boolean;
+};
+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 interface Formatter {
+    format: FormatFunction;
+}
+interface FormatterStatic {
+    type: 'formatter';
+    new (): Formatter;
+}
+export declare type TolgeeModule = FormatterStatic;
+export declare type FormatFunction = (props: {
+    translation: string;
+    params: Record<string, any>;
+    language: string;
+}) => string | any[];
+export {};

package/dist/wrappers/AbstractWrapper.d.ts

@@ -0,0 +1,8 @@
+import { TranslationTags, TranslationParamsTags, Unwrapped } from '../types';
+export interface AbstractWrapper {
+    handleText(node: Element): Promise<void>;
+    handleSubtree(node: Element): Promise<void>;
+    handleAttribute(node: Element): Promise<void>;
+    wrap: (key: string, params?: TranslationParamsTags<any>, defaultValue?: string | undefined, translation?: TranslationTags<any>) => TranslationTags<any>;
+    unwrap(text: string): Unwrapped;
+}

package/dist/wrappers/NodeHandler.d.ts

@@ -0,0 +1,18 @@
+import { Properties } from '../Properties';
+import { ElementWithMeta, KeyAndParamsTags, NodeWithMeta } from '../types';
+import { ElementRegistrar } from '../services/ElementRegistrar';
+import { AbstractWrapper } from './AbstractWrapper';
+export declare class NodeHandler {
+    private properties;
+    private elementRegistrar;
+    private wrapper;
+    constructor(properties: Properties, elementRegistrar: ElementRegistrar, wrapper: AbstractWrapper);
+    static initParentElement(element: Element): ElementWithMeta;
+    filterRestricted<T extends Element | Text>(nodes: T[]): T[];
+    handleNodes(nodes: Array<Text | Attr>): Promise<void>;
+    translateChildNode(node: Text | Attr, newValue: any, keys: KeyAndParamsTags<any>[]): NodeWithMeta;
+    private lockNode;
+    private unlockNode;
+    private getParentElement;
+    private getSuitableParent;
+}

package/dist/wrappers/WrappedHandler.d.ts

@@ -0,0 +1,8 @@
+import { NodeHandler } from './NodeHandler';
+import { ElementRegistrar } from '../services/ElementRegistrar';
+export declare class WrappedHandler {
+    private elementRegistrar;
+    private nodeHandler;
+    constructor(elementRegistrar: ElementRegistrar, nodeHandler: NodeHandler);
+    handle(node: Node): Promise<void>;
+}

package/dist/wrappers/invisible/AttributeHandler.d.ts

@@ -0,0 +1,8 @@
+import { NodeHandler } from '../NodeHandler';
+import { Properties } from '../../Properties';
+export declare class AttributeHandler {
+    private properties;
+    private nodeHandler;
+    constructor(properties: Properties, nodeHandler: NodeHandler);
+    handle(node: Element): Promise<void>;
+}

package/dist/wrappers/invisible/Coder.d.ts

@@ -0,0 +1,7 @@
+import { TranslationTags, TranslationParamsTags, Unwrapped } from '../../types';
+export declare class Coder {
+    private keyMemory;
+    private defaultMemory;
+    unwrap(text: string): Unwrapped;
+    wrap(key: string, _params?: TranslationParamsTags<any>, defaultValue?: string | undefined, translation?: string | any[] | undefined): TranslationTags<any>;
+}

package/dist/wrappers/invisible/ContentHandler.d.ts

@@ -0,0 +1,6 @@
+import { NodeHandler } from '../NodeHandler';
+export declare class ContentHandler {
+    private nodeHandler;
+    constructor(nodeHandler: NodeHandler);
+    handle(node: Node): Promise<void>;
+}

package/dist/wrappers/invisible/CoreHandler.d.ts

@@ -0,0 +1,10 @@
+import { ContentHandler } from './ContentHandler';
+import { AttributeHandler } from './AttributeHandler';
+import { WrappedHandler } from '../WrappedHandler';
+export declare class CoreHandler {
+    private textHandler;
+    private attributeHandler;
+    private wrappedHandler;
+    constructor(textHandler: ContentHandler, attributeHandler: AttributeHandler, wrappedHandler: WrappedHandler);
+    handleSubtree(target: Element): Promise<void>;
+}

package/dist/wrappers/invisible/InvisibleWrapper.d.ts

@@ -0,0 +1,18 @@
+import { Properties } from '../../Properties';
+import { ElementRegistrar } from '../../services/ElementRegistrar';
+import { TranslationParams } from '../../types';
+import { AbstractWrapper } from '../AbstractWrapper';
+export declare class InvisibleWrapper implements AbstractWrapper {
+    private coder;
+    private coreHandler;
+    private attributeHandler;
+    private wrappedHandler;
+    private textHandler;
+    private nodeHandler;
+    constructor(properties: Properties, elementRegistrar: ElementRegistrar);
+    handleText(node: Element): Promise<void>;
+    handleSubtree(node: Element): Promise<void>;
+    handleAttribute(node: Element): Promise<void>;
+    wrap(key: string, params?: TranslationParams, defaultValue?: string | undefined, translation?: string): import("../../types").TranslationTags<any>;
+    unwrap(text: string): import("../../types").Unwrapped;
+}

package/dist/wrappers/invisible/ValueMemory.d.ts

@@ -0,0 +1,5 @@
+export declare class ValueMemory {
+    private values;
+    valueToNumber(key: string): number;
+    numberToValue(num: number): string;
+}

package/dist/wrappers/invisible/ValueMemory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wrappers/text/AttributeHandler.d.ts

@@ -0,0 +1,8 @@
+import { NodeHandler } from '../NodeHandler';
+import { Properties } from '../../Properties';
+export declare class AttributeHandler {
+    private properties;
+    private nodeHandler;
+    constructor(properties: Properties, nodeHandler: NodeHandler);
+    handle(node: Element): Promise<void>;
+}

package/dist/wrappers/text/AttributeHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wrappers/text/Coder.d.ts

@@ -0,0 +1,15 @@
+import { Properties } from '../../Properties';
+import { TextService } from '../../services/TextService';
+import { TranslationParams, Unwrapped } from '../../types';
+export declare class Coder {
+    private properties;
+    private textService;
+    constructor(properties: Properties, textService: TextService);
+    private get rawUnWrapRegex();
+    private static parseUnwrapped;
+    unwrap(text: string): Unwrapped;
+    wrap(key: string, params?: TranslationParams, defaultValue?: string | undefined): string;
+    private getTranslatedWithMetadata;
+    private readonly escapeForRegExp;
+    private readonly escapeParam;
+}

package/dist/wrappers/text/Coder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wrappers/text/ContentHandler.d.ts

@@ -0,0 +1,8 @@
+import { Properties } from '../../Properties';
+import { NodeHandler } from '../NodeHandler';
+export declare class ContentHandler {
+    private properties;
+    private nodeHandler;
+    constructor(properties: Properties, nodeHandler: NodeHandler);
+    handle(node: Node): Promise<void>;
+}

package/dist/wrappers/text/ContentHandler.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/wrappers/text/CoreHandler.d.ts

@@ -0,0 +1,17 @@
+import { ContentHandler } from './ContentHandler';
+import { EventService } from '../../services/EventService';
+import { Properties } from '../../Properties';
+import { AttributeHandler } from './AttributeHandler';
+import { WrappedHandler } from '../WrappedHandler';
+import { Coder } from './Coder';
+export declare class CoreHandler {
+    private textHandler;
+    private eventService;
+    private properties;
+    private attributeHandler;
+    private coder;
+    private wrappedHandler;
+    constructor(textHandler: ContentHandler, eventService: EventService, properties: Properties, attributeHandler: AttributeHandler, coder: Coder, wrappedHandler: WrappedHandler);
+    handleSubtree(target: Element): Promise<void>;
+    private refresh;
+}

package/dist/wrappers/text/CoreHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/wrappers/text/TextWrapper.d.ts

@@ -0,0 +1,20 @@
+import { Properties } from '../../Properties';
+import { ElementRegistrar } from '../../services/ElementRegistrar';
+import { EventService } from '../../services/EventService';
+import { TextService } from '../../services/TextService';
+import { TranslationParams } from '../../types';
+import { AbstractWrapper } from '../AbstractWrapper';
+export declare class TextWrapper implements AbstractWrapper {
+    private coder;
+    private coreHandler;
+    private attributeHandler;
+    private wrappedHandler;
+    private textHandler;
+    private nodeHandler;
+    constructor(eventService: EventService, properties: Properties, textService: TextService, elementRegistrar: ElementRegistrar);
+    handleText(node: Element): Promise<void>;
+    handleSubtree(node: Element): Promise<void>;
+    handleAttribute(node: Element): Promise<void>;
+    wrap(key: string, params: TranslationParams, defaultValue: string | undefined, translation: string): string;
+    unwrap(text: string): import("../../types").Unwrapped;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tolgee/core",
-  "version": "4.7.4-rc.1a63ba95.0",
+  "version": "4.8.6",
   "description": "Library providing ability to translate messages directly in context of developed application.",
   "main": "index.js",
   "module": "./dist/tolgee.esm.mjs",
@@ -43,19 +43,19 @@
   "devDependencies": {
     "@rollup/plugin-node-resolve": "13.3.0",
     "@rollup/plugin-replace": "^4.0.0",
-    "@rollup/plugin-typescript": "8.3.3",
+    "@rollup/plugin-typescript": "8.3.4",
     "@testing-library/dom": "^8.7.1",
     "@testing-library/jest-dom": "^5.11.4",
     "@types/jest": "^27.0.2",
     "@types/node": "^17.0.8",
     "@types/testing-library__jest-dom": "^5.14.5",
-    "concurrently": "7.2.2",
+    "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.56.3",
+    "rollup": "^2.78.1",
     "rollup-plugin-terser": "7.0.2",
     "ts-jest": "^27.0.5",
     "tslib": "^2.4.0",
@@ -67,7 +67,7 @@
     "require": "./dist/tolgee.cjs.js",
     "import": "./dist/tolgee.esm.mjs"
   },
-  "gitHead": "06304d7d8c64febbf3489bd19c4e5f390f594ecc",
+  "gitHead": "80769a4fb18fef78600998371e7e7f67e83026b0",
   "publishConfig": {
     "access": "public"
   }

package/src/services/CoreService.test.ts

@@ -54,7 +54,6 @@ describe('CoreService', () => {
     test('will return languages returned from api http service', async () => {
       expect(await coreService.getLanguages()).toEqual(new Set(dummyLanguages));
       expect(mockedFetchJson).toBeCalledTimes(1);
-      expect(mockedFetchJson).toBeCalledWith(`v2/projects/languages?size=1000`);
     });
 
     test('sets preferred languages of properties', async () => {

package/src/services/CoreService.ts

@@ -18,7 +18,7 @@ export class CoreService {
   async getLanguages(): Promise<Set<string>> {
     if (!(this.languagePromise instanceof Promise)) {
       this.languagePromise = this.apiHttpService.fetchJson(
-        `v2/projects/languages?size=1000`
+        `v2/projects/languages?size=1000&sort=tag`
       );
     }