@tolgee/web 4.9.3-rc.d287ae9.0

package/lib/BackendFetch.d.ts

@@ -0,0 +1,4 @@
+import type { BackendInterface, TolgeePlugin } from '@tolgee/core';
+import { BackendOptions } from './types';
+export declare const BackendFetchCreator: (options?: Partial<BackendOptions>) => BackendInterface;
+export declare const BackendFetch: (options?: Partial<BackendOptions>) => TolgeePlugin;

package/lib/BrowserExtensionPlugin/BrowserExtensionPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { TolgeePlugin } from '@tolgee/core';
+export declare const API_KEY_LOCAL_STORAGE = "__tolgee_apiKey";
+export declare const API_URL_LOCAL_STORAGE = "__tolgee_apiUrl";
+export declare type BrowserExtensionProps = {
+    noReload?: boolean;
+};
+declare let BrowserExtensionPlugin: () => TolgeePlugin;
+export { BrowserExtensionPlugin };

package/lib/BrowserExtensionPlugin/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const IN_CONTEXT_FILE = "tolgee-in-context-tools.umd.min.js";
+export declare const IN_CONTEXT_UMD_NAME = "@tolgee/in-context-tools";
+export declare const IN_CONTEXT_EXPORT_NAME = "InContextTools";

package/lib/BrowserExtensionPlugin/loadInContextLib.d.ts

@@ -0,0 +1 @@
+export declare function loadInContextLib(version?: string): Promise<(overrideCredentials?: import("@tolgee/core").DevCredentials) => import("@tolgee/core").TolgeePlugin>;

package/lib/ContextUi.d.ts

@@ -0,0 +1,2 @@
+import { TolgeePlugin } from '@tolgee/core';
+export declare const ContextUi: () => TolgeePlugin;

package/lib/DevBackend.d.ts

@@ -0,0 +1,2 @@
+import { TolgeePlugin } from '@tolgee/core';
+export declare const DevBackend: () => TolgeePlugin;

package/lib/DevTools.d.ts

@@ -0,0 +1,3 @@
+import { InContextTools } from './InContextTools';
+declare let DevTools: typeof InContextTools;
+export { DevTools };

package/lib/InContextTools.d.ts

@@ -0,0 +1,2 @@
+import type { DevCredentials, TolgeePlugin } from '@tolgee/core';
+export declare const InContextTools: (overrideCredentials?: DevCredentials) => TolgeePlugin;

package/lib/InvisibleObserver.d.ts

@@ -0,0 +1,2 @@
+import type { TolgeePlugin } from '@tolgee/core';
+export declare const InvisibleObserver: () => TolgeePlugin;

package/lib/LanguageDetector.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageDetectorInterface, TolgeePlugin } from '@tolgee/core';
+export declare const LanguageDetectorCreator: () => LanguageDetectorInterface;
+export declare const LanguageDetector: () => TolgeePlugin;

package/lib/LanguageStorage.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageStorageInterface, TolgeePlugin } from '@tolgee/core';
+export declare const LanguageStorageCreator: () => LanguageStorageInterface;
+export declare const LanguageStorage: () => TolgeePlugin;

package/lib/TextObserver.d.ts

@@ -0,0 +1,2 @@
+import type { TolgeePlugin } from '@tolgee/core';
+export declare const TextObserver: () => TolgeePlugin;

package/lib/WebTolgee.d.ts

@@ -0,0 +1,3 @@
+import { Options, Tolgee as TolgeeCore, TolgeeInstance } from '@tolgee/core';
+export declare const Tolgee: (options?: Partial<Options>) => TolgeeInstance;
+export { TolgeeCore };

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ContextUi';
+export * from './DevTools';
+export * from './InContextTools';
+export * from './typedIndex';

package/lib/observers/general/DomHelper.d.ts

@@ -0,0 +1,4 @@
+import { ObserverOptions } from '@tolgee/core';
+export declare const DomHelper: (options: ObserverOptions) => Readonly<{
+    getSuitableParent: (node: Node) => Element;
+}>;

package/lib/observers/general/ElementHighlighter.d.ts

@@ -0,0 +1,10 @@
+import { ElementMeta } from '@tolgee/core';
+import { TolgeeElement } from '../../types';
+declare type Props = {
+    highlightColor: string;
+    highlightWidth: number;
+};
+export declare const ElementHighlighter: ({ highlightColor, highlightWidth, }: Props) => Readonly<{
+    initHighlighter: (element: TolgeeElement, elementMeta: ElementMeta) => void;
+}>;
+export {};

package/lib/observers/general/ElementMeta.d.ts

@@ -0,0 +1,3 @@
+import type { ElementMeta, KeyAndParams, NodeMeta } from '@tolgee/core';
+export declare function initElementMeta(): ElementMeta;
+export declare function initNodeMeta(oldTextContent: string, keys: KeyAndParams[]): NodeMeta;

package/lib/observers/general/ElementRegistry.d.ts

@@ -0,0 +1,11 @@
+import { FallbackNSTranslation } from '@tolgee/core';
+import { ElementMeta, NodeMeta, TranslationOnClick, ObserverOptions } from '@tolgee/core';
+import { TolgeeElement } from '../../types';
+export declare const ElementRegistry: (options: ObserverOptions, onClick: TranslationOnClick) => Readonly<{
+    register: (element: Element, node: Node, nodeMeta: NodeMeta) => void;
+    forEachElement: (callback: (el: TolgeeElement, meta: ElementMeta) => void) => void;
+    findAll: (key?: string, ns?: FallbackNSTranslation) => ElementMeta[];
+    refreshAll: () => void;
+    run: (mouseHighlight: boolean) => void;
+    stop: () => void;
+}>;

package/lib/observers/general/ElementStore.d.ts

@@ -0,0 +1,10 @@
+import type { ElementMeta } from '@tolgee/core';
+import { TolgeeElement } from '../../types';
+export declare type RegistredElementsMap = Map<TolgeeElement, ElementMeta>;
+export declare const ElementStore: () => Readonly<{
+    set: (el: TolgeeElement, meta: ElementMeta) => void;
+    get: (el: TolgeeElement | undefined) => ElementMeta | undefined;
+    remove: (el: TolgeeElement) => boolean;
+    forEachElement: (callback: (el: TolgeeElement, meta: ElementMeta) => void) => void;
+}>;
+export declare type ElementStoreType = ReturnType<typeof ElementStore>;

package/lib/observers/general/GeneralObserver.d.ts

@@ -0,0 +1,12 @@
+import { FallbackNSTranslation, TranslationOnClick, WrapperInterface, ObserverRunProps, ObserverOptions } from '@tolgee/core';
+export declare const GeneralObserver: (wrapper: WrapperInterface, options: ObserverOptions, onClick: TranslationOnClick) => Readonly<{
+    run: ({ mouseHighlight }: ObserverRunProps) => void;
+    stop: () => void;
+    wrap: import("@tolgee/core").WrapperWrapFunction;
+    unwrap: import("@tolgee/core").WrapperUnwrapFunction;
+    forEachElement: (callback: (el: import("../..").TolgeeElement, meta: import("@tolgee/core").ElementMeta) => void) => void;
+    highlight: (key?: string, ns?: FallbackNSTranslation) => {
+        unhighlight(): void;
+    };
+}>;
+export declare type GeneralObserverType = ReturnType<typeof GeneralObserver>;

package/lib/observers/general/MouseEventHandler.d.ts

@@ -0,0 +1,13 @@
+import { TolgeeElement } from '../../types';
+import { ModifierKey } from '@tolgee/core';
+import { ElementStoreType } from './ElementStore';
+declare type Props = {
+    highlightKeys: ModifierKey[];
+    elementStore: ElementStoreType;
+    onClick: (event: MouseEvent, el: TolgeeElement) => void;
+};
+export declare const MouseEventHandler: ({ highlightKeys, elementStore, onClick, }: Props) => Readonly<{
+    run: () => void;
+    stop: () => void;
+}>;
+export {};

package/lib/observers/general/NodeHandler.d.ts

@@ -0,0 +1,6 @@
+import { WrapperInterface, ObserverOptions } from '@tolgee/core';
+export declare const NodeHandler: (options: ObserverOptions, wrapper: WrapperInterface) => Readonly<{
+    handleAttributes: (node: Node) => Attr[];
+    handleChildList: (node: Node) => (Attr | Text)[];
+    handleText: (node: Node) => Text[];
+}>;

package/lib/observers/general/helpers.d.ts

@@ -0,0 +1,7 @@
+import { KeyDescriptorInternal } from '@tolgee/core';
+export declare function xPathEvaluate<T extends Node>(expression: string, targetNode: Node): Node[];
+export declare function closestElement(node: Element | Text): Element | null;
+export declare function getNodeText(node: Node): string | null;
+export declare function setNodeText(node: Node, text: string): void;
+export declare function nodeContains(descendant: Node, node: Node): boolean;
+export declare const compareDescriptors: (descriptor: KeyDescriptorInternal, criteria: KeyDescriptorInternal) => boolean;

package/lib/observers/invisible/InvisibleWrapper.d.ts

@@ -0,0 +1,2 @@
+import type { WrapperInterface } from '@tolgee/core';
+export declare const InvisibleWrapper: () => WrapperInterface;

package/lib/observers/invisible/ValueMemory.d.ts

@@ -0,0 +1,5 @@
+export declare const ValueMemory: () => Readonly<{
+    valueToNumber: (key: string) => number;
+    numberToValue: (num: number) => string;
+}>;
+export declare type ValueMemoryInstance = ReturnType<typeof ValueMemory>;

package/lib/observers/invisible/encoderPolyfill.d.ts

@@ -0,0 +1,8 @@
+export declare const Encoder: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export declare const Decoder: {
+    new (label?: string | undefined, options?: TextDecoderOptions | undefined): TextDecoder;
+    prototype: TextDecoder;
+};

package/lib/observers/invisible/secret.d.ts

@@ -0,0 +1,6 @@
+export declare const INVISIBLE_CHARACTERS: string[];
+export declare const INVISIBLE_REGEX: RegExp;
+export declare const encodeMessage: (text: string) => string;
+export declare const decodeFromText: (text: string) => string[];
+export declare const removeSecrets: (text: string) => string;
+export declare const stringToCodePoints: (text: string) => number[];

package/lib/observers/text/TextWrapper.d.ts

@@ -0,0 +1,8 @@
+import type { TranslatePropsInternal, WrapperInterface } from '@tolgee/core';
+declare type Props = {
+    inputPrefix: string;
+    inputSuffix: string;
+    translate: (params: TranslatePropsInternal) => string;
+};
+export declare const TextWrapper: ({ inputPrefix, inputSuffix, translate, }: Props) => WrapperInterface;
+export {};

package/lib/observers/text/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function splitOnNonEscapedDelimiter(string: string, delimiter: string): string[];
+export declare function isCharEscaped(position: number, fullString: string): boolean;
+export declare function removeEscapes(string: string): string;

package/lib/tools/decodeApiKey.d.ts

@@ -0,0 +1 @@
+export declare function getProjectIdFromApiKey(key: string | undefined): number | undefined;

package/lib/tools/extension.d.ts

@@ -0,0 +1,28 @@
+declare type Props = {
+    message: string;
+    recievingMessage: string[];
+    data?: any;
+    attempts?: number;
+};
+export declare function listen<T = any>(type: string[], callback: (data?: T) => any): {
+    unsubscribe: () => void;
+};
+export declare function sendAndRecieve<T>({ message, recievingMessage, data, attempts, }: Props): {
+    cancel: () => boolean;
+    promise: Promise<T>;
+};
+export declare function takeScreenshot(): Promise<string>;
+export declare function detectExtension(): Promise<boolean>;
+export declare type LibConfig = {
+    uiPresent: boolean;
+    uiVersion?: string;
+    mode: 'production' | 'development';
+    config: {
+        apiUrl: string;
+        apiKey: string;
+    };
+};
+export declare function Handshaker(): {
+    update: (data: LibConfig) => Promise<boolean>;
+};
+export {};

package/lib/typedIndex.d.ts

@@ -0,0 +1,11 @@
+export { InvisibleObserver } from './InvisibleObserver';
+export { TextObserver } from './TextObserver';
+export { DevBackend } from './DevBackend';
+export { getProjectIdFromApiKey } from './tools/decodeApiKey';
+export { BrowserExtensionPlugin } from './BrowserExtensionPlugin/BrowserExtensionPlugin';
+export { LanguageStorage } from './LanguageStorage';
+export { LanguageDetector } from './LanguageDetector';
+export { BackendFetch } from './BackendFetch';
+export * from './types';
+export * from '@tolgee/core';
+export { Tolgee, TolgeeCore } from './WebTolgee';

package/lib/types.d.ts

@@ -0,0 +1,28 @@
+export declare type NodeLock = {
+    locked?: boolean;
+};
+export declare type TolgeeElement = Element & ElementCSSInlineStyle & {
+    _tolgee?: boolean;
+};
+import type { BackendGetRecordProps, TreeTranslationsData } from '@tolgee/core';
+export declare type BackendOptions = Omit<RequestInit, 'headers'> & {
+    /**
+     * Path prefix (default: '/i18n')
+     */
+    prefix: string;
+    /**
+     * Generate own path based on namespace, language and prefix
+     */
+    getPath: GetPath;
+    /**
+     * Custom headers
+     */
+    headers: Record<string, string>;
+    /**
+     * Extract data from fetch response (default: (r) => r.json())
+     */
+    getData: (r: Response) => Promise<TreeTranslationsData | undefined>;
+};
+export declare type GetPath = (options: BackendGetRecordProps & {
+    prefix: string;
+}) => string;

package/lib/ui/KeyContextMenu/KeyContextMenu.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface KeyContextMenuParams {
+    openEvent: MouseEvent;
+    keys: Map<string, string | undefined>;
+    onSelect: (key: string | undefined) => void;
+}
+export declare type KeyContextMenuState = Partial<KeyContextMenuParams> & {
+    opened: boolean;
+};
+export declare class KeyContextMenu extends React.Component {
+    state: KeyContextMenuState & {
+        opened: boolean;
+    };
+    show(params: KeyContextMenuParams): Promise<void>;
+    keyDown: (e: KeyboardEvent) => void;
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(): JSX.Element;
+}

package/lib/ui/KeyDialog/KeyDialog.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import type { FallbackNSTranslation, UiProps } from '@tolgee/core';
+export declare type ComponentDependencies = UiProps;
+export declare type Props = UiProps;
+declare type State = {
+    key: null | string;
+    defaultValue: undefined | string;
+    dialogOpened: boolean;
+    ns: FallbackNSTranslation;
+};
+export declare class KeyDialog extends React.Component<Props, State> {
+    state: {
+        key: null;
+        defaultValue: undefined;
+        dialogOpened: boolean;
+        ns: undefined;
+    };
+    constructor(props: Props);
+    translationEdit(key: string, defaultValue: string | undefined, ns: FallbackNSTranslation): void;
+    render: () => JSX.Element;
+    private onClose;
+}
+export {};

package/lib/ui/KeyDialog/KeyForm.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const KeyForm: () => JSX.Element;

package/lib/ui/KeyDialog/LanguageSelect.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const LanguageSelect: React.FC;

package/lib/ui/KeyDialog/NewWindow.d.ts

@@ -0,0 +1,2 @@
+import { FC } from 'react';
+export declare const NewWindow: FC;

package/lib/ui/KeyDialog/NsSelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { FallbackNSTranslation } from '@tolgee/core';
+declare type Props = {
+    options: FallbackNSTranslation;
+    value: string;
+    onChange: (value: string) => void;
+};
+export declare const NsSelect: React.FC<Props>;
+export {};

package/lib/ui/KeyDialog/ScreenshotGallery/ExtensionPrompt.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare type Props = {
+    onClose: () => void;
+};
+export declare const ExtensionPrompt: React.FC<Props>;
+export {};

package/lib/ui/KeyDialog/ScreenshotGallery/ScreenshotDetail.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ScreenshotInterface } from '../TranslationDialogContextProvider';
+declare type Props = {
+    screenshot: ScreenshotInterface;
+    onClose: () => void;
+};
+export declare const ScreenshotDetail: React.FC<Props>;
+export {};

package/lib/ui/KeyDialog/ScreenshotGallery/ScreenshotDropzone.d.ts

@@ -0,0 +1,6 @@
+import { FunctionComponent } from 'react';
+export interface ScreenshotDropzoneProps {
+    validateAndUpload: (files: File[]) => void;
+    enabled: boolean;
+}
+export declare const ScreenshotDropzone: FunctionComponent<ScreenshotDropzoneProps>;

package/lib/ui/KeyDialog/ScreenshotGallery/ScreenshotGallery.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ScreenshotGallery: React.FC;

package/lib/ui/KeyDialog/ScreenshotGallery/ScreenshotThumbnail.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ScreenshotInterface } from '../TranslationDialogContextProvider';
+export declare type Props = {
+    onClick: () => void;
+    onDelete?: (id: number) => void;
+    data: ScreenshotInterface;
+};
+export declare const ScreenshotThumbnail: React.FC<Props>;

package/lib/ui/KeyDialog/ScreenshotGallery/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const MAX_FILE_COUNT = 20;
+export declare const dataTransferItemsToArray: (items: DataTransferItemList) => File[];
+export declare function isAuthorizedTo(scope: string, scopes: string[] | undefined): boolean;

package/lib/ui/KeyDialog/TranslationDialog.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const TranslationDialog: () => JSX.Element;

package/lib/ui/KeyDialog/TranslationDialogContextProvider.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="react" />
+import { FallbackNSTranslation, UiProps } from '@tolgee/core';
+export interface ScreenshotInterface {
+    id: number;
+    filename: string;
+    fileUrl: string;
+    createdAt?: string;
+    justUploaded: boolean;
+}
+declare type FormTranslations = {
+    [key: string]: string;
+};
+declare type DialogProps = {
+    keyName: string;
+    defaultValue: string;
+    open: boolean;
+    onClose: () => void;
+    uiProps: UiProps;
+    ns: FallbackNSTranslation;
+};
+declare type Actions = {
+    type: 'ON_INPUT_CHANGE';
+    payload: {
+        key: string;
+        value: string;
+    };
+} | {
+    type: 'ON_SELECTED_LANGUAGES_CHANGE';
+    payload: {
+        languages: string[];
+    };
+} | {
+    type: 'HANDLE_UPLOAD_IMAGES';
+    payload: {
+        files: File[];
+    };
+} | {
+    type: 'HANDLE_TAKE_SCREENSHOT';
+} | {
+    type: 'HANDLE_REMOVE_SCREENSHOT';
+    payload: {
+        id: number;
+    };
+} | {
+    type: 'ON_SAVE';
+} | {
+    type: 'ON_CLOSE';
+} | {
+    type: 'SET_USE_BROWSER_WINDOW';
+    payload: boolean;
+} | {
+    type: 'SET_CONTAINER';
+    payload: Element | undefined;
+} | {
+    type: 'OPEN_SCREENSHOT_DETAIL';
+    payload: ScreenshotInterface;
+} | {
+    type: 'CLOSE_SCREENSHOT_DETAIL';
+} | {
+    type: 'ON_ESCAPE';
+} | {
+    type: 'SELECTED_NS_CHANGE';
+    payload: {
+        ns: string;
+    };
+};
+export declare const DialogProvider: import("react").FC<DialogProps>, useDialogDispatch: () => (action: Actions) => Promise<void>, useDialogContext: <SelectorReturn>(selector: (state: {
+    input: string;
+    open: boolean;
+    ns: string | string[] | undefined;
+    selectedNs: string;
+    loading: boolean;
+    saving: boolean;
+    success: boolean;
+    error: any;
+    availableLanguages: {
+        id: number;
+        name: string;
+        tag: string;
+        originalName?: string | undefined;
+        flagEmoji?: string | undefined;
+        base: boolean;
+    }[] | undefined;
+    selectedLanguages: string[];
+    formDisabled: boolean;
+    translations: {
+        keyId: number;
+        keyName: string;
+        keyTags: {
+            id: number;
+            name: string;
+        }[];
+        screenshotCount: number;
+        screenshots?: {
+            id: number;
+            filename: string;
+            thumbnail: string;
+            fileUrl: string;
+            thumbnailUrl: string;
+            createdAt?: string | undefined;
+        }[] | undefined;
+        translations: {
+            [key: string]: {
+                id: number;
+                text?: string | undefined;
+                state: "UNTRANSLATED" | "TRANSLATED" | "REVIEWED";
+                auto: boolean;
+                mtProvider?: "GOOGLE" | "AWS" | "DEEPL" | "AZURE" | undefined;
+                commentCount: number;
+                unresolvedCommentCount: number;
+                fromTranslationMemory: boolean;
+            };
+        };
+    } | undefined;
+    translationsForm: FormTranslations;
+    container: Element | undefined;
+    useBrowserWindow: boolean;
+    pluginAvailable: boolean | undefined;
+    takingScreenshot: boolean;
+    screenshotsUploading: boolean;
+    screenshots: ScreenshotInterface[];
+    screenshotDetail: ScreenshotInterface | null;
+    linkToPlatform: string | undefined;
+    keyExists: boolean;
+    scopes: string[] | undefined;
+    permittedLanguageIds: number[] | undefined;
+}) => SelectorReturn) => SelectorReturn;
+export {};

package/lib/ui/KeyDialog/TranslationDialogWrapper.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const TranslationDialogWrapper: React.FC;

package/lib/ui/KeyDialog/TranslationFields.d.ts

@@ -0,0 +1,2 @@
+import { FunctionComponent } from 'react';
+export declare const TranslationFields: FunctionComponent;

package/lib/ui/KeyDialog/languageHelpers.d.ts

@@ -0,0 +1,12 @@
+import { components } from '../client/apiSchema.generated';
+declare type LanguageModel = components['schemas']['LanguageModel'];
+export declare const putBaseLangFirst: (languages: LanguageModel[] | undefined) => {
+    id: number;
+    name: string;
+    tag: string;
+    originalName?: string | undefined;
+    flagEmoji?: string | undefined;
+    base: boolean;
+}[] | undefined;
+export declare const putBaseLangFirstTags: (strings: Array<string>, base?: string) => string[];
+export {};

package/lib/ui/KeyDialog/tools.d.ts

@@ -0,0 +1,3 @@
+export declare function getPreferredLanguages(): string[];
+export declare function setPreferredLanguages(languages: string[]): void;
+export declare function getInitialLanguages(available: string[]): string[];

package/lib/ui/ThemeProvider.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ThemeProvider: React.FC;

package/lib/ui/client/QueryProvider.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare type GlobalOptions = {
+    apiKey: string;
+    apiUrl: string;
+};
+export declare const QueryContext: React.Context<GlobalOptions>;
+declare type Props = {
+    apiKey: string;
+    apiUrl: string;
+};
+export declare const QueryProvider: React.FC<Props>;
+export {};