@tolgee/svelte 4.9.2 → 5.0.0-rc.9be0f0e.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 5.0.0-rc.9be0f0e.0 (2022-09-29)
+
+
+### Features
+
+* prepare for rc release ([9be0f0e](https://github.com/tolgee/tolgee-js/commit/9be0f0e475edfacf948ecf0b93979936aae7ae79))
+
+
+### BREAKING CHANGES
+
+* new tolgee API
+
+
+
+
+
 ## [4.9.2](https://github.com/tolgee/tolgee-js/compare/v4.9.1...v4.9.2) (2022-09-07)
 
 **Note:** Version bump only for package @tolgee/svelte

package/GlobalContextPlugin.d.ts

@@ -0,0 +1,4 @@
+import type { TolgeePlugin } from '@tolgee/core';
+import type { TolgeeSvelteContext } from './types';
+export declare const GlobalContextPlugin: () => TolgeePlugin;
+export declare function getGlobalContext(): TolgeeSvelteContext;

package/GlobalContextPlugin.js

@@ -0,0 +1,10 @@
+let globalContext;
+export const GlobalContextPlugin = () => (tolgee) => {
+    globalContext = {
+        tolgee,
+    };
+    return tolgee;
+};
+export function getGlobalContext() {
+    return globalContext;
+}

package/SveltePlugin.d.ts

@@ -0,0 +1,5 @@
+import type { TolgeePlugin } from '@tolgee/core';
+import type { ObserverOptions } from '@tolgee/devtools-web';
+declare type Props = Partial<ObserverOptions>;
+export declare const SveltePlugin: (props?: Props) => TolgeePlugin;
+export {};

package/SveltePlugin.js

@@ -0,0 +1,6 @@
+import { DevTools, BrowserExtensionPlugin } from '@tolgee/devtools-web';
+import { GlobalContextPlugin } from './GlobalContextPlugin';
+export const SveltePlugin = (props) => (tolgee) => tolgee
+    .use(BrowserExtensionPlugin({ noReload: true }))
+    .use(DevTools({ observer: props }))
+    .use(GlobalContextPlugin());

package/T.svelte

@@ -1,48 +1,17 @@
-<script>import getTolgeeContext from './getTolgeeContext';
-import { onDestroy } from 'svelte';
+<script>import getTranslateInternal from './getTranslateInternal';
 export let keyName;
-export let parameters = undefined;
+export let params = undefined;
 export let noWrap = false;
 export let defaultValue = undefined;
 if (!keyName) {
     console.error('Missing keyName prop!');
 }
-const tolgeeContext = getTolgeeContext();
-let translated = keyName
-    ? tolgeeContext.tolgee.instant(keyName, parameters, noWrap, true)
-    : '';
-const translate = () => {
-    if (keyName) {
-        tolgeeContext.tolgee
-            .translate({
-            key: keyName,
-            params: parameters,
-            noWrap,
-            defaultValue,
-        })
-            .then((result) => {
-            translated = result;
-        })
-            .catch(() => {
-            console.error('Failed to resolve translation for key: ', keyName);
-        });
-    }
-};
-const onTranslationChangeSubscription = tolgeeContext.tolgee.onTranslationChange.subscribe((changeData) => {
-    if (changeData.key === keyName) {
-        translate();
-    }
-});
-const onLangChangeSubscription = tolgeeContext.tolgee.onLangChange.subscribe(() => {
-    translate();
-});
-if (typeof window !== 'undefined') {
-    onDestroy(() => {
-        onTranslationChangeSubscription.unsubscribe();
-        onLangChangeSubscription.unsubscribe();
-    });
-}
-$: translate();
+const { t } = getTranslateInternal();
 </script>
 
-{translated}
+{$t({
+  key: keyName,
+  params: params,
+  noWrap: noWrap,
+  defaultValue: defaultValue
+})}

package/T.svelte.d.ts

@@ -2,7 +2,7 @@ import { SvelteComponentTyped } from "svelte";
 declare const __propDef: {
     props: {
         keyName: string;
-        parameters?: Record<string, unknown> | undefined;
+        params?: Record<string, unknown> | undefined;
         noWrap?: boolean;
         defaultValue?: any;
     };

package/TolgeeProvider.svelte

@@ -1,33 +1,26 @@
 <script>import { onDestroy, onMount, setContext } from 'svelte';
-import { IcuFormatter, Tolgee, TolgeeConfig } from '@tolgee/core';
-export let config;
-const tolgee = Tolgee.use(IcuFormatter).init({
-    wrapperMode: 'invisible',
-    ui: process.env.NODE_ENV !== 'development'
-        ? undefined
-        : typeof require !== 'undefined'
-            ? require('@tolgee/ui')
-            : import('@tolgee/ui'),
-    ...(config || new TolgeeConfig()),
-});
-let tolgeeRunPromise;
+export let tolgee;
+export let fallback = undefined;
+let isLoading = !tolgee.isLoaded();
 setContext('tolgeeContext', {
     tolgee,
 });
 if (typeof window !== 'undefined') {
-    onMount(() => (tolgeeRunPromise = tolgee.run()));
+    onMount(() => {
+        tolgee.run().then(() => {
+            isLoading = false;
+        });
+    });
     onDestroy(tolgee.stop);
 }
 </script>
 
-{#if !tolgee.initialLoading}
+{#if !isLoading }
   <slot />
-{:else if !tolgeeRunPromise}
-  <slot name="loading-fallback" />
-{:else}
-  {#await tolgeeRunPromise}
+{:else }
+  {#if fallback}
+    {fallback}
+  {:else}
     <slot name="loading-fallback" />
-  {:then _}
-    <slot />
-  {/await}
+  {/if}
 {/if}

package/TolgeeProvider.svelte.d.ts

@@ -1,8 +1,9 @@
 import { SvelteComponentTyped } from "svelte";
-import { TolgeeConfig } from '@tolgee/core';
+import type { TolgeeInstance } from '@tolgee/core';
 declare const __propDef: {
     props: {
-        config: TolgeeConfig;
+        tolgee: TolgeeInstance;
+        fallback?: any;
     };
     events: {
         [evt: string]: CustomEvent<any>;

package/getTolgee.d.ts

@@ -0,0 +1,98 @@
+import type { TolgeeEvent } from '@tolgee/core';
+export declare const getTolgee: (events?: TolgeeEvent[]) => {
+    subscribe: (this: void, run: import("svelte/store").Subscriber<Readonly<{
+        on: import("@tolgee/core").TolgeeOn;
+        onKeyUpdate: (handler: import("@tolgee/core").ListenerHandler<void>) => import("@tolgee/core").ListenerSelective;
+        use: (plugin: import("@tolgee/core").TolgeePlugin) => Readonly<any>;
+        getLanguage: () => string;
+        getPendingLanguage: () => string;
+        changeLanguage: (language: string) => Promise<void>;
+        changeTranslation: import("@tolgee/core").ChangeTranslationInterface;
+        addActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation, forget?: boolean) => Promise<void>;
+        removeActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation) => void;
+        loadRecords: (descriptors: import("@tolgee/core").CacheDescriptor[]) => Promise<import("@tolgee/core").TranslationsFlat[]>;
+        loadRecord: (descriptors: import("@tolgee/core").CacheDescriptor) => Promise<import("@tolgee/core").TranslationsFlat>;
+        addStaticData: (data: {
+            [key: string]: import("@tolgee/core").TreeTranslationsData | (() => Promise<import("@tolgee/core").TreeTranslationsData>);
+        }) => void;
+        getRecord: (descriptor: import("@tolgee/core").CacheDescriptorInternal) => import("@tolgee/core").TranslationsFlat;
+        getAllRecords: () => import("@tolgee/core").CachePublicRecord[];
+        isInitialLoading: () => boolean;
+        isLoading: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isLoaded: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isFetching: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isRunning: () => boolean;
+        highlight: import("@tolgee/core").HighlightInterface;
+        getInitialOptions: () => import("@tolgee/core").Options;
+        isDev: () => boolean;
+        init: (options: Partial<import("@tolgee/core").Options>) => Readonly<any>;
+        run: () => Promise<void>;
+        stop: () => void;
+        t: (props: import("@tolgee/core").TranslatePropsInternal) => string;
+        wrap: (params: import("@tolgee/core").TranslatePropsInternal) => string;
+        unwrap: (text: string) => import("@tolgee/core").Unwrapped;
+    }>>, invalidate?: (value?: Readonly<{
+        on: import("@tolgee/core").TolgeeOn;
+        onKeyUpdate: (handler: import("@tolgee/core").ListenerHandler<void>) => import("@tolgee/core").ListenerSelective;
+        use: (plugin: import("@tolgee/core").TolgeePlugin) => Readonly<any>;
+        getLanguage: () => string;
+        getPendingLanguage: () => string;
+        changeLanguage: (language: string) => Promise<void>;
+        changeTranslation: import("@tolgee/core").ChangeTranslationInterface;
+        addActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation, forget?: boolean) => Promise<void>;
+        removeActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation) => void;
+        loadRecords: (descriptors: import("@tolgee/core").CacheDescriptor[]) => Promise<import("@tolgee/core").TranslationsFlat[]>;
+        loadRecord: (descriptors: import("@tolgee/core").CacheDescriptor) => Promise<import("@tolgee/core").TranslationsFlat>;
+        addStaticData: (data: {
+            [key: string]: import("@tolgee/core").TreeTranslationsData | (() => Promise<import("@tolgee/core").TreeTranslationsData>);
+        }) => void;
+        getRecord: (descriptor: import("@tolgee/core").CacheDescriptorInternal) => import("@tolgee/core").TranslationsFlat;
+        getAllRecords: () => import("@tolgee/core").CachePublicRecord[];
+        isInitialLoading: () => boolean;
+        isLoading: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isLoaded: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isFetching: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isRunning: () => boolean;
+        highlight: import("@tolgee/core").HighlightInterface;
+        getInitialOptions: () => import("@tolgee/core").Options;
+        isDev: () => boolean;
+        init: (options: Partial<import("@tolgee/core").Options>) => Readonly<any>;
+        run: () => Promise<void>;
+        stop: () => void;
+        t: (props: import("@tolgee/core").TranslatePropsInternal) => string;
+        wrap: (params: import("@tolgee/core").TranslatePropsInternal) => string;
+        unwrap: (text: string) => import("@tolgee/core").Unwrapped;
+    }>) => void) => import("svelte/store").Unsubscriber;
+    value: Readonly<{
+        on: import("@tolgee/core").TolgeeOn;
+        onKeyUpdate: (handler: import("@tolgee/core").ListenerHandler<void>) => import("@tolgee/core").ListenerSelective;
+        use: (plugin: import("@tolgee/core").TolgeePlugin) => Readonly<any>;
+        getLanguage: () => string;
+        getPendingLanguage: () => string;
+        changeLanguage: (language: string) => Promise<void>;
+        changeTranslation: import("@tolgee/core").ChangeTranslationInterface;
+        addActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation, forget?: boolean) => Promise<void>;
+        removeActiveNs: (ns: import("@tolgee/core").FallbackNSTranslation) => void;
+        loadRecords: (descriptors: import("@tolgee/core").CacheDescriptor[]) => Promise<import("@tolgee/core").TranslationsFlat[]>;
+        loadRecord: (descriptors: import("@tolgee/core").CacheDescriptor) => Promise<import("@tolgee/core").TranslationsFlat>;
+        addStaticData: (data: {
+            [key: string]: import("@tolgee/core").TreeTranslationsData | (() => Promise<import("@tolgee/core").TreeTranslationsData>);
+        }) => void;
+        getRecord: (descriptor: import("@tolgee/core").CacheDescriptorInternal) => import("@tolgee/core").TranslationsFlat;
+        getAllRecords: () => import("@tolgee/core").CachePublicRecord[];
+        isInitialLoading: () => boolean;
+        isLoading: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isLoaded: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isFetching: (ns?: import("@tolgee/core").FallbackNSTranslation) => boolean;
+        isRunning: () => boolean;
+        highlight: import("@tolgee/core").HighlightInterface;
+        getInitialOptions: () => import("@tolgee/core").Options;
+        isDev: () => boolean;
+        init: (options: Partial<import("@tolgee/core").Options>) => Readonly<any>;
+        run: () => Promise<void>;
+        stop: () => void;
+        t: (props: import("@tolgee/core").TranslatePropsInternal) => string;
+        wrap: (params: import("@tolgee/core").TranslatePropsInternal) => string;
+        unwrap: (text: string) => import("@tolgee/core").Unwrapped;
+    }>;
+};

package/getTolgee.js

@@ -0,0 +1,14 @@
+import { readable } from 'svelte/store';
+import { getTolgeeContext } from './getTolgeeContext';
+const DEFAULT_EVENTS = ['language', 'pendingLanguage'];
+export const getTolgee = (events = DEFAULT_EVENTS) => {
+    const tolgeeContext = getTolgeeContext();
+    const tolgee = tolgeeContext.tolgee;
+    const { subscribe } = readable(tolgee, (set) => {
+        const listeners = events.map((e) => tolgee.on(e, () => {
+            set({ ...tolgee });
+        }));
+        return () => listeners.forEach((listener) => listener.unsubscribe());
+    });
+    return { subscribe, value: tolgee };
+};

package/getTolgeeContext.d.ts

@@ -1,10 +1,6 @@
-import type { Tolgee } from '@tolgee/core';
-export declare type TolgeeContext = {
-    tolgee: Tolgee;
-};
+import type { TolgeeSvelteContext } from './types';
 /**
  * Returns Tolgee context.
  * @throws Error when context is not defined.
  */
-declare const getTolgeeContext: () => TolgeeContext;
-export default getTolgeeContext;
+export declare const getTolgeeContext: () => TolgeeSvelteContext;

package/getTolgeeContext.js

@@ -1,13 +1,14 @@
 import { getContext } from 'svelte';
+import { getGlobalContext } from './GlobalContextPlugin';
 /**
  * Returns Tolgee context.
  * @throws Error when context is not defined.
  */
-const getTolgeeContext = () => {
-    const context = getContext('tolgeeContext');
+export const getTolgeeContext = () => {
+    const context = (getContext('tolgeeContext') ||
+        getGlobalContext());
     if (context === undefined) {
         throw Error('Tolgee context is undefined. Trying to use getTranslate method or T component outside TolgeeProvider?');
     }
     return context;
 };
-export default getTolgeeContext;

package/getTranslate.d.ts

@@ -1,3 +1,7 @@
-import type { GetTranslateType } from './types';
-declare const getTranslate: GetTranslateType;
+import { type Readable } from 'svelte/store';
+import { type FallbackNSTranslation, type TFnType } from '@tolgee/core';
+declare const getTranslate: (ns?: FallbackNSTranslation) => {
+    t: Readable<TFnType<import("@tolgee/core").DefaultParamType, string>>;
+    isLoading: Readable<boolean>;
+};
 export default getTranslate;

package/getTranslate.js

@@ -1,88 +1,13 @@
-import { derived, writable } from 'svelte/store';
-import { onDestroy } from 'svelte';
-import { getTolgeeContext } from './index';
-const getTranslate = () => {
-    const context = getTolgeeContext();
-    const tolgee = context.tolgee;
-    // set of used keys
-    // to get updated just when specific key translation changes
-    const keys = new Set();
-    // dummy store which is updated to forces providing of new translate method
-    const updateStore = writable(0);
-    const update = () => updateStore.update((number) => number + 1);
-    const translate = (key, parameters, noWrap, defaultValue) => {
-        if (!keys.has(key)) {
-            keys.add(key);
-        }
-        // get result from sync method instant, which is not reliable, since
-        // languages may not be loaded yet
-        const instantTranslated = tolgee.instant({
-            key: key,
-            params: parameters,
-            noWrap: noWrap,
-            defaultValue: defaultValue,
-        });
-        // so we have to use also translate method, to get reliable result
-        tolgee
-            .translate({ key: key, params: parameters, noWrap, defaultValue })
-            .then((translated) => {
-            // when the result value is different, we have to update the store and
-            // so return new translate function
-            if (instantTranslated !== translated) {
-                update();
-            }
-        });
-        return instantTranslated;
-    };
-    // subscribe for translation change
-    const onTranslationChangeSubscription = tolgee.onTranslationChange.subscribe(async (changeData) => {
-        // update only when this getTranslate translated the changed key value
-        if (keys.has(changeData.key)) {
-            update();
-        }
-    });
-    // subscribe for language change
-    const onLangChangeSubscription = tolgee.onLangChange.subscribe(async () => {
-        // wait for translations to be loaded, so we are waiting for translation of any key
-        await tolgee.translate('key');
-        update();
-    });
-    if (typeof window !== 'undefined') {
-        //unsubscribe on destroy
-        onDestroy(() => {
-            onTranslationChangeSubscription.unsubscribe();
-            onLangChangeSubscription.unsubscribe();
-        });
-    }
-    // return new translate method when something is changed
-    return derived(
-    // when updateStore changes, translate function gets changed as well
-    updateStore, () => (keyOrProps, ...params) => {
-        let parameters = undefined;
-        let noWrap = undefined;
-        let defaultValue = undefined;
-        // allow user to pass object of params and make the code cleaner
-        const key = typeof keyOrProps === 'object' ? keyOrProps.key : keyOrProps;
-        if (typeof keyOrProps === 'object') {
-            parameters = keyOrProps.parameters;
-            noWrap = keyOrProps.noWrap;
-            defaultValue = keyOrProps.defaultValue;
-        }
-        else {
-            params.forEach((param) => {
-                switch (typeof param) {
-                    case 'object':
-                        parameters = param;
-                        break;
-                    case 'boolean':
-                        noWrap = param;
-                        break;
-                    case 'string':
-                        defaultValue = param;
-                }
-            });
-        }
-        return translate(key, parameters, noWrap, defaultValue);
+import { derived } from 'svelte/store';
+import { getTranslateParams, } from '@tolgee/core';
+import getTranslateInternal from './getTranslateInternal';
+const getTranslate = (ns) => {
+    const { t: tInternal, isLoading } = getTranslateInternal(ns);
+    const t = derived(tInternal, (value) => (...params) => {
+        //@ts-ignore
+        const props = getTranslateParams(...params);
+        return value(props);
     });
+    return { t, isLoading };
 };
 export default getTranslate;

package/getTranslateInternal.d.ts

@@ -0,0 +1,10 @@
+import { type Readable } from 'svelte/store';
+import { type FallbackNSTranslation, type TranslateProps } from '@tolgee/core';
+declare const getTranslateInternal: (ns?: FallbackNSTranslation) => {
+    t: {
+        subscribe: (this: void, run: import("svelte/store").Subscriber<(props: TranslateProps<any>) => string>, invalidate?: (value?: (props: TranslateProps<any>) => string) => void) => import("svelte/store").Unsubscriber;
+        value: import("svelte/store").Writable<(props: TranslateProps<any>) => string>;
+    };
+    isLoading: Readable<boolean>;
+};
+export default getTranslateInternal;

package/getTranslateInternal.js

@@ -0,0 +1,41 @@
+import { writable } from 'svelte/store';
+import { onDestroy } from 'svelte';
+import { getFallback, } from '@tolgee/core';
+import { getTolgeeContext } from './index';
+const getTranslateInternal = (ns) => {
+    const namespaces = getFallback(ns);
+    const tolgeeContext = getTolgeeContext();
+    const tolgee = tolgeeContext?.tolgee;
+    if (!tolgee) {
+        throw new Error('Tolgee instance not provided');
+    }
+    const tFunction = createTFunction();
+    const t = writable(tFunction);
+    const subscription = tolgee.onKeyUpdate(() => {
+        t.set(createTFunction());
+        isLoading.set(!tolgee.isLoaded(namespaces));
+    });
+    subscription.subscribeNs(namespaces);
+    tolgee.addActiveNs(namespaces);
+    onDestroy(() => {
+        subscription?.unsubscribe();
+        tolgee.removeActiveNs(namespaces);
+    });
+    const isLoading = writable(!tolgee.isLoaded(namespaces));
+    const subscribeToKey = (key) => {
+        subscription.subscribeKey(key);
+    };
+    function createTFunction() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (props) => {
+            const fallbackNs = props.ns || namespaces?.[0];
+            subscribeToKey({ key: props.key, ns: fallbackNs });
+            return tolgee.t({ ...props, ns: fallbackNs });
+        };
+    }
+    return {
+        t: { subscribe: t.subscribe, value: t },
+        isLoading: { subscribe: isLoading.subscribe },
+    };
+};
+export default getTranslateInternal;

package/index.d.ts

@@ -1,5 +1,8 @@
 export { default as T } from './T.svelte';
 export { default as getTranslate } from './getTranslate';
 export { default as TolgeeProvider } from './TolgeeProvider.svelte';
-export { default as getTolgeeContext } from './getTolgeeContext';
-export { getLanguageStore } from './getLanguageStore';
+export { getTolgeeContext } from './getTolgeeContext';
+export { SveltePlugin } from './SveltePlugin';
+export { getTolgee } from './getTolgee';
+export * from '@tolgee/core';
+export * from '@tolgee/devtools-web';

package/index.js

@@ -1,5 +1,8 @@
 export { default as T } from './T.svelte';
 export { default as getTranslate } from './getTranslate';
 export { default as TolgeeProvider } from './TolgeeProvider.svelte';
-export { default as getTolgeeContext } from './getTolgeeContext';
-export { getLanguageStore } from './getLanguageStore';
+export { getTolgeeContext } from './getTolgeeContext';
+export { SveltePlugin } from './SveltePlugin';
+export { getTolgee } from './getTolgee';
+export * from '@tolgee/core';
+export * from '@tolgee/devtools-web';

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@tolgee/svelte",
-  "version": "4.9.2",
+  "version": "5.0.0-rc.9be0f0e.0",
   "dependencies": {
-    "@tolgee/core": "^4.9.2",
-    "@tolgee/ui": "^4.9.2"
+    "@tolgee/core": "^5.0.0-rc.9be0f0e.0",
+    "@tolgee/devtools-web": "^5.0.0-rc.9be0f0e.0",
+    "@tolgee/format-icu": "^5.0.0-rc.9be0f0e.0"
   },
   "devDependencies": {
     "@sveltejs/adapter-auto": "1.0.0-next.65",
@@ -11,6 +12,7 @@
     "@sveltejs/package": "1.0.0-next.1",
     "@testing-library/jest-dom": "^5.16.5",
     "@testing-library/svelte": "^3.2.1",
+    "@tsconfig/svelte": "^3.0.0",
     "@types/jest": "^28.1.7",
     "@typescript-eslint/eslint-plugin": "^5.34.0",
     "@typescript-eslint/parser": "^5.34.0",
@@ -39,11 +41,14 @@
   },
   "exports": {
     "./package.json": "./package.json",
+    "./GlobalContextPlugin": "./GlobalContextPlugin.js",
+    "./SveltePlugin": "./SveltePlugin.js",
     "./T.svelte": "./T.svelte",
     "./TolgeeProvider.svelte": "./TolgeeProvider.svelte",
-    "./getLanguageStore": "./getLanguageStore.js",
+    "./getTolgee": "./getTolgee.js",
     "./getTolgeeContext": "./getTolgeeContext.js",
     "./getTranslate": "./getTranslate.js",
+    "./getTranslateInternal": "./getTranslateInternal.js",
     ".": "./index.js",
     "./types": "./types.js"
   },

package/types.d.ts

@@ -1,15 +1,4 @@
-import type { TranslationParams } from '@tolgee/core';
-import type { Readable } from 'svelte/store';
-export declare type GetTranslateResultFnProps = {
-    key: string;
-    parameters?: TranslationParams;
-    noWrap?: boolean;
-    defaultValue?: string;
+import type { TolgeeInstance } from '@tolgee/core';
+export declare type TolgeeSvelteContext = {
+    tolgee: TolgeeInstance;
 };
-export declare type GetTranslateType = () => Readable<{
-    (props: GetTranslateResultFnProps): string;
-    (key: string, defaultValue?: string, noWrap?: boolean): string;
-    (key: string, defaultValue?: string, parameters?: TranslationParams): string;
-    (key: string, parameters?: TranslationParams, defaultValue?: string): string;
-    (key: string, parameters?: TranslationParams, noWrap?: boolean, defaultValue?: string): string;
-}>;

package/getLanguageStore.d.ts

@@ -1,2 +0,0 @@
-import type { Writable } from 'svelte/store';
-export declare const getLanguageStore: () => Writable<string>;

package/getLanguageStore.js

@@ -1,13 +0,0 @@
-import { writable } from 'svelte/store';
-import { getTolgeeContext } from './index';
-export const getLanguageStore = () => {
-    const context = getTolgeeContext();
-    const store = writable(context.tolgee.lang);
-    context.tolgee.onLangChange.subscribe((lang) => {
-        store.set(lang);
-    });
-    store.subscribe((lang) => {
-        context.tolgee.changeLanguage(lang);
-    });
-    return store;
-};