svelte-intlayer 7.1.8 → 7.1.9

package/dist/editor/ContentSelector.svelte.d.ts

@@ -0,0 +1,35 @@
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const ContentSelector: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    onClickOutside?: (() => void) | undefined;
+    pressDuration?: number;
+    isSelecting?: boolean;
+    onPress?: (() => void) | undefined;
+    onUnhover?: (() => void) | undefined;
+    onHover?: (() => void) | undefined;
+    onClick?: ((event: MouseEvent) => void) | undefined;
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type ContentSelector = InstanceType<typeof ContentSelector>;
+export default ContentSelector;

package/dist/editor/ContentSelectorWrapper.svelte

@@ -0,0 +1,69 @@
+<script lang="ts">
+import { isSameKeyPath, type NodeProps } from '@intlayer/core';
+import { MessageKey } from '@intlayer/editor';
+import { NodeType } from '@intlayer/types';
+import { get } from 'svelte/store';
+import ContentSelector from './ContentSelector.svelte';
+import { useCommunicator } from './communicator';
+import { useEditorEnabled } from './editorEnabled';
+import { useFocusDictionary } from './focusDictionary';
+import { useEditor } from './useEditor';
+
+export let dictionaryKey: NodeProps['dictionaryKey'];
+export let keyPath: NodeProps['keyPath'];
+
+const { focusedContent, setFocusedContent } = useFocusDictionary();
+const editorEnabled = useEditorEnabled();
+const communicatorStore = useCommunicator();
+const { enabled } = editorEnabled;
+
+useEditor();
+
+$: filteredKeyPath = keyPath.filter((key) => key.type !== NodeType.Translation);
+
+$: isSelected =
+  $focusedContent?.dictionaryKey === dictionaryKey &&
+  ($focusedContent?.keyPath?.length ?? 0) > 0 &&
+  isSameKeyPath($focusedContent?.keyPath ?? [], filteredKeyPath);
+
+const handleSelect = () => {
+  setFocusedContent({
+    dictionaryKey,
+    keyPath: filteredKeyPath,
+  });
+};
+
+const handleHover = () => {
+  const { postMessage, senderId } = get(communicatorStore);
+  postMessage({
+    type: `${MessageKey.INTLAYER_HOVERED_CONTENT_CHANGED}/post`,
+    data: {
+      dictionaryKey,
+      keyPath: filteredKeyPath,
+    },
+    senderId,
+  });
+};
+
+const handleUnhover = () => {
+  const { postMessage, senderId } = get(communicatorStore);
+  postMessage({
+    type: `${MessageKey.INTLAYER_HOVERED_CONTENT_CHANGED}/post`,
+    data: null,
+    senderId,
+  });
+};
+</script>
+
+{#if $enabled}
+  <ContentSelector
+    onPress={handleSelect}
+    isSelecting={isSelected}
+    onHover={handleHover}
+    onUnhover={handleUnhover}
+  >
+    <slot />
+  </ContentSelector>
+{:else}
+  <slot />
+{/if}

package/dist/editor/ContentSelectorWrapper.svelte.d.ts

@@ -0,0 +1,31 @@
+import { type NodeProps } from '@intlayer/core';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+type $$__sveltets_2_PropsWithChildren<Props, Slots> = Props & (Slots extends {
+    default: any;
+} ? Props extends Record<string, never> ? any : {
+    children?: any;
+} : {});
+declare const ContentSelectorWrapper: $$__sveltets_2_IsomorphicComponent<$$__sveltets_2_PropsWithChildren<{
+    dictionaryKey: NodeProps["dictionaryKey"];
+    keyPath: NodeProps["keyPath"];
+}, {
+    default: {};
+}>, {
+    [evt: string]: CustomEvent<any>;
+}, {
+    default: {};
+}, {}, string>;
+type ContentSelectorWrapper = InstanceType<typeof ContentSelectorWrapper>;
+export default ContentSelectorWrapper;

package/dist/{types/editor → editor}/communicator.d.ts

@@ -1,4 +1,4 @@
-import { Writable } from 'svelte/store';
+import { type Writable } from 'svelte/store';
 export type Communicator = {
     postMessage: typeof window.postMessage;
     allowedOrigins?: string[];

package/dist/editor/communicator.js

@@ -0,0 +1,54 @@
+import configuration from '@intlayer/config/built';
+import { getContext, setContext } from 'svelte';
+import { writable } from 'svelte/store';
+const randomUUID = () => Math.random().toString(36).slice(2);
+const { editor } = configuration;
+const postMessage = (data) => {
+    if (typeof window === 'undefined')
+        return;
+    const isInIframe = window.self !== window.top;
+    if (!isInIframe)
+        return;
+    if (editor.applicationURL.length > 0) {
+        window.postMessage(data, editor.applicationURL);
+    }
+    if (editor.editorURL.length > 0) {
+        window.parent.postMessage(data, editor.editorURL);
+    }
+    if (editor.cmsURL.length > 0) {
+        window.parent.postMessage(data, editor.cmsURL);
+    }
+};
+const defaultValue = {
+    postMessage,
+    allowedOrigins: [
+        editor?.applicationURL,
+        editor?.editorURL,
+        editor?.cmsURL,
+    ],
+    senderId: randomUUID(),
+};
+const COMMUNICATOR_KEY = Symbol('INTLAYER_COMMUNICATOR');
+export const createCommunicator = (options = {}) => {
+    const store = writable({
+        ...defaultValue,
+        ...options,
+    });
+    setContext(COMMUNICATOR_KEY, store);
+    return store;
+};
+export const useCommunicator = () => {
+    let context;
+    // `getContext` must only run inside a component.
+    // If this is called in plain JS, we catch the error and fallback.
+    try {
+        context = getContext(COMMUNICATOR_KEY);
+    }
+    catch {
+        // called outside component -> ignore, we’ll use global store
+    }
+    if (!context) {
+        return createCommunicator();
+    }
+    return context;
+};

package/dist/{types/editor → editor}/dictionariesRecord.d.ts

@@ -1,5 +1,5 @@
-import { Dictionary, LocalDictionaryId } from '@intlayer/types';
+import type { Dictionary, LocalDictionaryId } from '@intlayer/types';
 export type DictionaryContent = Record<LocalDictionaryId, Dictionary>;
 export declare const useDictionariesRecord: () => {
-    dictionariesRecord: import('svelte/store').Writable<DictionaryContent | undefined>;
+    dictionariesRecord: import("svelte/store").Writable<DictionaryContent | undefined>;
 };

package/dist/editor/dictionariesRecord.js

@@ -0,0 +1,16 @@
+import { MessageKey } from '@intlayer/editor';
+import { getUnmergedDictionaries } from '@intlayer/unmerged-dictionaries-entry';
+import { useCrossFrameState } from './useCrossFrameState';
+let loaded = false;
+export const useDictionariesRecord = () => {
+    const [dictionariesRecord, setDictionariesRecord] = useCrossFrameState(MessageKey.INTLAYER_LOCALE_DICTIONARIES_CHANGED, {});
+    if (!loaded && typeof window !== 'undefined') {
+        const unmergedDictionaries = getUnmergedDictionaries();
+        const dictionariesList = Object.fromEntries(Object.values(unmergedDictionaries)
+            .flat()
+            .map((dictionary) => [dictionary.localId, dictionary]));
+        setDictionariesRecord(dictionariesList);
+        loaded = true;
+    }
+    return { dictionariesRecord };
+};

package/dist/{types/editor → editor}/editorEnabled.d.ts

@@ -1,4 +1,4 @@
-import { Readable, Writable } from 'svelte/store';
+import { type Readable, type Writable } from 'svelte/store';
 export type EditorEnabledStateProps = {
     settingEnabled: Writable<boolean>;
     wrapperEnabled: Writable<boolean>;

package/dist/editor/editorEnabled.js

@@ -0,0 +1,41 @@
+import configuration from '@intlayer/config/built';
+import { getContext, setContext } from 'svelte';
+import { derived, writable } from 'svelte/store';
+const EDITOR_ENABLED_KEY = Symbol('EDITOR_ENABLED');
+const detectIframe = () => {
+    if (typeof window === 'undefined')
+        return false;
+    return window.self !== window.top;
+};
+export const createEditorEnabledClient = () => {
+    const settingEnabled = writable(configuration.editor.enabled);
+    const wrapperEnabled = writable(false);
+    const isInIframe = writable(false);
+    const enabled = derived([settingEnabled, wrapperEnabled, isInIframe], ([$setting, $wrapper, $iframe]) => $setting && $wrapper && $iframe);
+    if (typeof window !== 'undefined') {
+        isInIframe.set(detectIframe());
+    }
+    const state = {
+        settingEnabled,
+        wrapperEnabled,
+        isInIframe,
+        enabled,
+    };
+    setContext(EDITOR_ENABLED_KEY, state);
+    return state;
+};
+export const useEditorEnabled = () => {
+    let context;
+    // `getContext` must only run inside a component.
+    // If this is called in plain JS, we catch the error and fallback.
+    try {
+        context = getContext(EDITOR_ENABLED_KEY);
+    }
+    catch {
+        // called outside component -> ignore, we’ll use global store
+    }
+    if (!context) {
+        return createEditorEnabledClient();
+    }
+    return context;
+};

package/dist/{types/editor → editor}/focusDictionary.d.ts

@@ -1,5 +1,5 @@
-import { DictionaryKeys, KeyPath } from '@intlayer/types';
-import { Writable } from 'svelte/store';
+import type { DictionaryKeys, KeyPath } from '@intlayer/types';
+import type { Writable } from 'svelte/store';
 export type FocusedContent = {
     dictionaryKey: DictionaryKeys;
     keyPath: KeyPath[];

package/dist/editor/focusDictionary.js

@@ -0,0 +1,22 @@
+import { MessageKey } from '@intlayer/editor';
+import { getContext, setContext } from 'svelte';
+import { useCrossFrameState } from './useCrossFrameState';
+const FOCUS_DICTIONARY_KEY = Symbol('FOCUS_DICTIONARY');
+export const createFocusDictionaryClient = () => {
+    const [focusedContent, setFocusedContent] = useCrossFrameState(MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED, null);
+    setContext(FOCUS_DICTIONARY_KEY, { focusedContent, setFocusedContent });
+    return { focusedContent, setFocusedContent };
+};
+export const useFocusDictionary = () => {
+    let context;
+    try {
+        context = getContext(FOCUS_DICTIONARY_KEY);
+    }
+    catch {
+        // called outside component -> ignore, we’ll use global store
+    }
+    if (!context) {
+        return createFocusDictionaryClient();
+    }
+    return context;
+};

package/dist/editor/index.js

@@ -0,0 +1,9 @@
+export { default as ContentSelector } from './ContentSelector.svelte';
+export { default as ContentSelectorWrapper } from './ContentSelectorWrapper.svelte';
+export * from './communicator';
+export * from './editorEnabled';
+export * from './focusDictionary';
+export * from './useCrossFrameMessageListener';
+export * from './useCrossFrameState';
+export * from './useEditor';
+export * from './useIframeClickInterceptor';

package/dist/{types/editor → editor}/useCrossFrameMessageListener.d.ts

@@ -1,2 +1,2 @@
-import { MessageKey } from '@intlayer/editor';
+import { type MessageKey } from '@intlayer/editor';
 export declare const useCrossFrameMessageListener: <S>(key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`, onEventTriggered?: (data: S) => void, autoCleanup?: boolean) => (data?: S) => void;

package/dist/editor/useCrossFrameMessageListener.js

@@ -0,0 +1,65 @@
+import { compareUrls } from '@intlayer/editor';
+import { onDestroy } from 'svelte';
+import { get } from 'svelte/store';
+import { useCommunicator } from './communicator';
+const subscribers = new Map();
+let windowListenerAttached = false;
+const addSubscriber = (key, cb) => {
+    let set = subscribers.get(key);
+    if (!set) {
+        set = new Set();
+        subscribers.set(key, set);
+    }
+    set.add(cb);
+};
+const removeSubscriber = (key, cb) => {
+    const set = subscribers.get(key);
+    if (!set)
+        return;
+    set.delete(cb);
+    if (set.size === 0)
+        subscribers.delete(key);
+};
+const ensureGlobalListener = (allowedOrigins, selfId) => {
+    if (windowListenerAttached)
+        return;
+    if (typeof window === 'undefined')
+        return;
+    window.addEventListener('message', (event) => {
+        const { type, data, senderId } = event.data ?? {};
+        if (!type)
+            return;
+        if (senderId === selfId)
+            return;
+        if (!allowedOrigins ||
+            allowedOrigins.includes('*') ||
+            allowedOrigins.some((o) => compareUrls(o, event.origin))) {
+            subscribers.get(type)?.forEach((cb) => {
+                cb(data);
+            });
+        }
+    });
+    windowListenerAttached = true;
+};
+export const useCrossFrameMessageListener = (key, onEventTriggered, autoCleanup = true) => {
+    const communicatorStore = useCommunicator();
+    const { allowedOrigins, senderId } = get(communicatorStore);
+    ensureGlobalListener(allowedOrigins, senderId);
+    if (onEventTriggered) {
+        const cb = onEventTriggered;
+        addSubscriber(key, cb);
+        if (autoCleanup) {
+            try {
+                onDestroy(() => removeSubscriber(key, cb));
+            }
+            catch {
+                // Might be called outside component, manual cleanup needed if needed
+            }
+        }
+    }
+    const postMessageWrapper = (data) => {
+        const { postMessage, senderId: currentSenderId } = get(communicatorStore);
+        postMessage({ type: key, data, senderId: currentSenderId }, '*');
+    };
+    return postMessageWrapper;
+};

package/dist/{types/editor → editor}/useCrossFrameState.d.ts

@@ -1,5 +1,5 @@
-import { MessageKey } from '@intlayer/editor';
-import { Writable } from 'svelte/store';
+import type { MessageKey } from '@intlayer/editor';
+import { type Writable } from 'svelte/store';
 export type CrossFrameStateOptions = {
     emit?: boolean;
     receive?: boolean;

package/dist/editor/useCrossFrameState.js

@@ -0,0 +1,82 @@
+import { get, writable } from 'svelte/store';
+import { useCommunicator } from './communicator';
+import { useCrossFrameMessageListener } from './useCrossFrameMessageListener';
+const crossFrameStateCache = new Map();
+const resolveState = (state, prevState) => {
+    if (typeof state === 'function') {
+        return state(prevState);
+    }
+    return state;
+};
+const toSerializable = (obj) => {
+    if (obj === null || obj === undefined)
+        return obj;
+    return JSON.parse(JSON.stringify(obj));
+};
+export const useCrossFrameState = (key, initialState, options = { emit: true, receive: true }) => {
+    if (crossFrameStateCache.has(key)) {
+        const { state, setState } = crossFrameStateCache.get(key);
+        return [state, setState];
+    }
+    const { emit = true, receive = true } = options;
+    // Initialize state
+    const initialValue = resolveState(initialState);
+    const state = writable(initialValue);
+    const communicatorStore = useCommunicator();
+    const broadcastState = (value) => {
+        const { postMessage, senderId } = get(communicatorStore);
+        if (!emit ||
+            typeof postMessage !== 'function' ||
+            typeof value === 'undefined') {
+            return;
+        }
+        postMessage({
+            type: `${key}/post`,
+            data: value,
+            senderId,
+        }, '*');
+    };
+    const setState = (valueOrUpdater) => {
+        state.update((prev) => {
+            const next = resolveState(valueOrUpdater, prev);
+            const serialised = toSerializable(next);
+            broadcastState(serialised);
+            return serialised;
+        });
+    };
+    const postState = () => {
+        const { postMessage, senderId } = get(communicatorStore);
+        if (typeof postMessage !== 'function')
+            return;
+        postMessage({
+            type: `${key}/post`,
+            data: get(state),
+            senderId,
+        }, '*');
+    };
+    // Emit initial state
+    broadcastState(initialValue);
+    // If receiving, ask for state
+    if (receive && typeof get(state) === 'undefined') {
+        const { postMessage, senderId } = get(communicatorStore);
+        if (typeof postMessage === 'function') {
+            postMessage({ type: `${key}/get`, senderId }, '*');
+        }
+    }
+    // Listen for updates
+    const listenerKey = receive ? `${key}/post` : `${key}/ignore`;
+    const listener = useCrossFrameMessageListener(listenerKey, (data) => {
+        if (receive) {
+            state.set(data);
+        }
+    });
+    // Listen for requests
+    const getListenerKey = emit ? `${key}/get` : `${key}/ignore`;
+    const getListener = useCrossFrameMessageListener(getListenerKey, (_) => {
+        if (emit) {
+            broadcastState(get(state));
+        }
+    });
+    crossFrameStateCache.set(key, { state, setState, postState });
+    return [state, setState];
+};

package/dist/editor/useEditor.js

@@ -0,0 +1,46 @@
+import { MessageKey } from '@intlayer/editor';
+import { onDestroy } from 'svelte';
+import { get } from 'svelte/store';
+import { useDictionariesRecord } from './dictionariesRecord';
+import { useEditorEnabled } from './editorEnabled';
+import { useCrossFrameMessageListener } from './useCrossFrameMessageListener';
+import { useIframeClickMerger } from './useIframeClickInterceptor';
+let initialized = false;
+let unsubscribeIsInIframe = null;
+export const useEditor = () => {
+    if (typeof window === 'undefined')
+        return;
+    if (initialized)
+        return;
+    initialized = true;
+    const editorEnabled = useEditorEnabled();
+    useDictionariesRecord();
+    useIframeClickMerger();
+    // Listen for editor enabled
+    useCrossFrameMessageListener(`${MessageKey.INTLAYER_EDITOR_ENABLED}/post`, (data) => {
+        editorEnabled.wrapperEnabled.set(data);
+    }, false);
+    const getEditorEnabled = useCrossFrameMessageListener(`${MessageKey.INTLAYER_EDITOR_ENABLED}/get`, (data) => {
+        editorEnabled.wrapperEnabled.set(data);
+    }, false);
+    // Initial check
+    const checkEnabled = () => {
+        const inIframe = get(editorEnabled.isInIframe);
+        const setting = get(editorEnabled.settingEnabled);
+        if (inIframe && setting) {
+            getEditorEnabled();
+        }
+    };
+    checkEnabled();
+    // Subscribe to changes
+    editorEnabled.isInIframe.subscribe(() => checkEnabled());
+    // Keep track of unsubscribe so we *could* clean up if we ever wanted
+    unsubscribeIsInIframe = editorEnabled.isInIframe.subscribe(() => checkEnabled());
+    onDestroy(() => {
+        initialized = false;
+        if (unsubscribeIsInIframe) {
+            unsubscribeIsInIframe();
+            unsubscribeIsInIframe = null;
+        }
+    });
+};

package/dist/editor/useIframeClickInterceptor.js

@@ -0,0 +1,29 @@
+import { MessageKey, mergeIframeClick } from '@intlayer/editor';
+import { onDestroy, onMount } from 'svelte';
+import { useCrossFrameMessageListener } from './useCrossFrameMessageListener';
+export const useIframeClickInterceptor = () => {
+    const postMessage = useCrossFrameMessageListener(MessageKey.INTLAYER_IFRAME_CLICKED);
+    const handler = () => {
+        postMessage();
+    };
+    onMount(() => {
+        if (typeof window !== 'undefined') {
+            window.addEventListener('mousedown', handler);
+        }
+    });
+    onDestroy(() => {
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('mousedown', handler);
+        }
+    });
+};
+export const useIframeClickMerger = () => {
+    useIframeClickInterceptor();
+    useCrossFrameMessageListener(MessageKey.INTLAYER_IFRAME_CLICKED, (data) => {
+        // mergeIframeClick(data); // mergeIframeClick expects an event, but data might be stripped?
+        // Actually mergeIframeClick logic in editor package probably dispatches a custom event or similar.
+        // The Vue implementation passes `mergeIframeClick` directly as the callback.
+        // Let's assume mergeIframeClick handles whatever data is passed, or we wrap it if needed.
+        mergeIframeClick(data);
+    });
+};

package/dist/{types/getDictionary.d.ts → getDictionary.d.ts}

@@ -1,6 +1,6 @@
-import { Plugins } from '@intlayer/core';
-import { DeclaredLocales, Dictionary, LocalesValues } from '@intlayer/types';
-import { DeepTransformContent } from './plugins';
+import { type Plugins } from '@intlayer/core';
+import type { DeclaredLocales, Dictionary, LocalesValues } from '@intlayer/types';
+import { type DeepTransformContent } from './plugins';
 /**
  * Get dictionary content for a specific locale in Svelte applications
  * @param dictionary The dictionary object to transform

package/dist/getDictionary.js

@@ -0,0 +1,18 @@
+import { getDictionary as getDictionaryCore, } from '@intlayer/core';
+import { intlayerNodePlugins, markdownPlugin, svelteNodePlugins, } from './plugins';
+/**
+ * Get dictionary content for a specific locale in Svelte applications
+ * @param dictionary The dictionary object to transform
+ * @param locale The target locale (optional, defaults to current locale)
+ * @param additionalPlugins Additional transformation plugins
+ * @returns Transformed dictionary content optimized for Svelte
+ */
+export const getDictionary = (dictionary, locale, additionalPlugins) => {
+    const plugins = [
+        intlayerNodePlugins,
+        svelteNodePlugins,
+        markdownPlugin,
+        ...(additionalPlugins ?? []),
+    ];
+    return getDictionaryCore(dictionary, locale, plugins);
+};

package/dist/{types/getIntlayer.d.ts → getIntlayer.d.ts}

@@ -1,6 +1,6 @@
-import { Plugins } from '@intlayer/core';
-import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types';
-import { DeepTransformContent } from './plugins';
+import { type Plugins } from '@intlayer/core';
+import type { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent, LocalesValues } from '@intlayer/types';
+import { type DeepTransformContent } from './plugins';
 /**
  * Get dictionary content by key for Svelte applications
  * @param key The dictionary key to retrieve

package/dist/getIntlayer.js

@@ -0,0 +1,18 @@
+import { getIntlayer as getIntlayerCore } from '@intlayer/core';
+import { intlayerNodePlugins, markdownPlugin, svelteNodePlugins, } from './plugins';
+/**
+ * Get dictionary content by key for Svelte applications
+ * @param key The dictionary key to retrieve
+ * @param locale The target locale (optional)
+ * @param additionalPlugins Additional transformation plugins
+ * @returns Transformed dictionary content optimized for Svelte
+ */
+export const getIntlayer = (key, locale, additionalPlugins) => {
+    const plugins = [
+        intlayerNodePlugins,
+        svelteNodePlugins,
+        markdownPlugin,
+        ...(additionalPlugins ?? []),
+    ];
+    return getIntlayerCore(key, locale, plugins);
+};

package/dist/{types/index.d.ts → index.d.ts}

@@ -1,6 +1,4 @@
-import { IInterpreterPluginSvelte } from './plugins';
-import { useEditor } from './editor';
-import { setMarkdownContext } from './markdown';
+import type { IInterpreterPluginSvelte } from './plugins';
 declare module '@intlayer/core' {
     interface IInterpreterPlugin<T, S, L> extends IInterpreterPluginSvelte<T> {
     }
@@ -9,4 +7,6 @@ export * from './client';
 export * from './getDictionary';
 export * from './getIntlayer';
 export * from './plugins';
+import { useEditor } from './editor';
+import { setMarkdownContext } from './markdown';
 export { useEditor as useIntlayerEditor, setMarkdownContext as setIntlayerMarkdown, };

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from './client';
+export * from './getDictionary';
+export * from './getIntlayer';
+export * from './plugins';
+import { useEditor } from './editor';
+import { setMarkdownContext } from './markdown';
+export { useEditor as useIntlayerEditor, setMarkdownContext as setIntlayerMarkdown, };

package/dist/index.test.d.ts

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

package/dist/index.test.js

@@ -0,0 +1,6 @@
+import { describe, expect, it } from 'vitest';
+describe('svelte-intlayer', () => {
+    it('should be defined', () => {
+        expect(true).toBe(true);
+    });
+});