angular-intlayer 5.5.8 → 5.5.10

package/dist/esm/editor/focusDictionary.mjs

@@ -0,0 +1,54 @@
+import { effect, signal } from "@angular/core";
+import { MessageKey } from "@intlayer/editor";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+let instance = null;
+const createFocusDictionaryClient = () => {
+  if (instance) return instance;
+  const focusedContentSignal = signal(null);
+  const setFocusedContent = (focussedContent) => {
+    focusedContentSignal.set(focussedContent);
+  };
+  const setFocusedContentKeyPath = (keyPath) => {
+    const current = focusedContentSignal();
+    if (!current) return;
+    setFocusedContent({ ...current, keyPath });
+  };
+  instance = {
+    focusedContent: focusedContentSignal.asReadonly(),
+    setFocusedContent,
+    setFocusedContentKeyPath
+  };
+  return instance;
+};
+const installFocusDictionary = (injector) => {
+  const client = createFocusDictionaryClient();
+};
+const useFocusDictionary = createSharedComposable(() => {
+  const client = createFocusDictionaryClient();
+  const [focusedContent, setFocusedContent] = useCrossFrameState(
+    MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED
+  );
+  if (!client) {
+    throw new Error("FocusDictionary state not found");
+  }
+  effect(() => {
+    const newValue = client.focusedContent();
+    if (JSON.stringify(newValue) !== JSON.stringify(focusedContent())) {
+      setFocusedContent(newValue);
+    }
+  });
+  effect(() => {
+    const newValue = focusedContent();
+    if (JSON.stringify(newValue) !== JSON.stringify(client.focusedContent())) {
+      client.setFocusedContent(newValue ?? null);
+    }
+  });
+  return client;
+});
+export {
+  createFocusDictionaryClient,
+  installFocusDictionary,
+  useFocusDictionary
+};
+//# sourceMappingURL=focusDictionary.mjs.map

package/dist/esm/editor/focusDictionary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/focusDictionary.ts"],"sourcesContent":["import { effect, Injector, signal, Signal } from '@angular/core';\nimport type { KeyPath } from '@intlayer/core';\nimport { MessageKey } from '@intlayer/editor';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport type FileContent = {\n  dictionaryKey: string;\n  keyPath?: KeyPath[];\n  dictionaryPath?: string;\n};\n\ntype FocusDictionaryClient = {\n  focusedContent: Signal<FileContent | null>;\n  setFocusedContent: (focussedContent: FileContent | null) => void;\n  setFocusedContentKeyPath: (keyPath: KeyPath[]) => void;\n};\n\n/**\n * Singleton instance\n */\nlet instance: FocusDictionaryClient | null = null;\n\n/**\n * Creates a focus dictionary client\n */\nexport const createFocusDictionaryClient = () => {\n  if (instance) return instance;\n\n  const focusedContentSignal = signal<FileContent | null>(null);\n\n  const setFocusedContent = (focussedContent: FileContent | null) => {\n    focusedContentSignal.set(focussedContent);\n  };\n\n  const setFocusedContentKeyPath = (keyPath: KeyPath[]) => {\n    const current = focusedContentSignal();\n    if (!current) return;\n    setFocusedContent({ ...current, keyPath });\n  };\n\n  instance = {\n    focusedContent: focusedContentSignal.asReadonly(),\n    setFocusedContent,\n    setFocusedContentKeyPath,\n  } as FocusDictionaryClient;\n\n  return instance;\n};\n\n/**\n * Helper to install the focus dictionary into the injector\n */\nexport const installFocusDictionary = (injector: Injector) => {\n  const client = createFocusDictionaryClient();\n\n  // Angular doesn't have a direct equivalent to Vue's app.provide\n  // The client is stored as a singleton and accessed via createFocusDictionaryClient\n};\n\n/** consumer */\nexport const useFocusDictionary = createSharedComposable(() => {\n  const client = createFocusDictionaryClient();\n  const [focusedContent, setFocusedContent] =\n    useCrossFrameState<FileContent | null>(\n      MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED\n    );\n\n  if (!client) {\n    throw new Error('FocusDictionary state not found');\n  }\n\n  // Use Angular effects instead of Vue watchers\n  // Watch local (client) and update cross-frame\n  effect(() => {\n    const newValue = client.focusedContent();\n    if (JSON.stringify(newValue) !== JSON.stringify(focusedContent())) {\n      setFocusedContent(newValue);\n    }\n  });\n\n  // Watch cross-frame and update local\n  effect(() => {\n    const newValue = focusedContent();\n    if (JSON.stringify(newValue) !== JSON.stringify(client.focusedContent())) {\n      client.setFocusedContent(newValue ?? null);\n    }\n  });\n\n  return client;\n});\n"],"mappings":"AAAA,SAAS,QAAkB,cAAsB;AAEjD,SAAS,kBAAkB;AAC3B,SAAS,8BAA8B;AACvC,SAAS,0BAA0B;AAiBnC,IAAI,WAAyC;AAKtC,MAAM,8BAA8B,MAAM;AAC/C,MAAI,SAAU,QAAO;AAErB,QAAM,uBAAuB,OAA2B,IAAI;AAE5D,QAAM,oBAAoB,CAAC,oBAAwC;AACjE,yBAAqB,IAAI,eAAe;AAAA,EAC1C;AAEA,QAAM,2BAA2B,CAAC,YAAuB;AACvD,UAAM,UAAU,qBAAqB;AACrC,QAAI,CAAC,QAAS;AACd,sBAAkB,EAAE,GAAG,SAAS,QAAQ,CAAC;AAAA,EAC3C;AAEA,aAAW;AAAA,IACT,gBAAgB,qBAAqB,WAAW;AAAA,IAChD;AAAA,IACA;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,yBAAyB,CAAC,aAAuB;AAC5D,QAAM,SAAS,4BAA4B;AAI7C;AAGO,MAAM,qBAAqB,uBAAuB,MAAM;AAC7D,QAAM,SAAS,4BAA4B;AAC3C,QAAM,CAAC,gBAAgB,iBAAiB,IACtC;AAAA,IACE,WAAW;AAAA,EACb;AAEF,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAIA,SAAO,MAAM;AACX,UAAM,WAAW,OAAO,eAAe;AACvC,QAAI,KAAK,UAAU,QAAQ,MAAM,KAAK,UAAU,eAAe,CAAC,GAAG;AACjE,wBAAkB,QAAQ;AAAA,IAC5B;AAAA,EACF,CAAC;AAGD,SAAO,MAAM;AACX,UAAM,WAAW,eAAe;AAChC,QAAI,KAAK,UAAU,QAAQ,MAAM,KAAK,UAAU,OAAO,eAAe,CAAC,GAAG;AACxE,aAAO,kBAAkB,YAAY,IAAI;AAAA,IAC3C;AAAA,EACF,CAAC;AAED,SAAO;AACT,CAAC;","names":[]}

package/dist/esm/editor/index.mjs

@@ -0,0 +1,10 @@
+import { ContentSelectorWrapperComponent } from "./ContentSelectorWrapper.component.mjs";
+import { EditedContentRendererComponent } from "./EditedContentRenderer.component.mjs";
+import { EditorSelectorRendererComponent } from "./EditorSelectorRenderer.component.mjs";
+export * from "./installIntlayerEditor.mjs";
+export {
+  ContentSelectorWrapperComponent,
+  EditedContentRendererComponent,
+  EditorSelectorRendererComponent
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/editor/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/index.ts"],"sourcesContent":["export { ContentSelectorWrapperComponent } from './ContentSelectorWrapper.component';\nexport { EditedContentRendererComponent } from './EditedContentRenderer.component';\nexport { EditorSelectorRendererComponent } from './EditorSelectorRenderer.component';\nexport * from './installIntlayerEditor';\n"],"mappings":"AAAA,SAAS,uCAAuC;AAChD,SAAS,sCAAsC;AAC/C,SAAS,uCAAuC;AAChD,cAAc;","names":[]}

package/dist/esm/editor/installIntlayerEditor.mjs

@@ -0,0 +1,38 @@
+import configuration from "@intlayer/config/built";
+import { installChangedContent } from "./changedContent.mjs";
+import { installCommunicator } from "./communicator.mjs";
+import { installDictionariesRecord } from "./dictionariesRecord.mjs";
+import { installEditedContent } from "./editedContent.mjs";
+import { installEditorEnabled } from "./editorEnabled.mjs";
+import { installFocusDictionary } from "./focusDictionary.mjs";
+const { editor } = configuration;
+const { applicationURL, editorURL, cmsURL } = editor ?? {};
+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 installIntlayerEditor = (injector) => {
+  installCommunicator(injector, {
+    postMessage,
+    allowedOrigins: [applicationURL, editorURL, cmsURL]
+  });
+  installEditorEnabled(injector);
+  installChangedContent(injector);
+  installDictionariesRecord(injector);
+  installEditedContent(injector);
+  installFocusDictionary(injector);
+};
+export {
+  installIntlayerEditor
+};
+//# sourceMappingURL=installIntlayerEditor.mjs.map

package/dist/esm/editor/installIntlayerEditor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/installIntlayerEditor.ts"],"sourcesContent":["import { Injector } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport { installChangedContent } from './changedContent';\nimport { installCommunicator } from './communicator';\nimport { installDictionariesRecord } from './dictionariesRecord';\nimport { installEditedContent } from './editedContent';\nimport { installEditorEnabled } from './editorEnabled';\nimport { installFocusDictionary } from './focusDictionary';\n\nconst { editor } = configuration;\nconst { applicationURL, editorURL, cmsURL } = editor ?? {};\n\nconst postMessage = (data: any) => {\n  if (typeof window === 'undefined') return;\n\n  const isInIframe = window.self !== window.top;\n\n  if (!isInIframe) return;\n\n  if (editor.applicationURL.length > 0) {\n    window.postMessage(data, editor.applicationURL);\n  }\n\n  if (editor.editorURL.length > 0) {\n    window.parent.postMessage(data, editor.editorURL);\n  }\n\n  if (editor.cmsURL.length > 0) {\n    window.parent.postMessage(data, editor.cmsURL);\n  }\n};\n\n/**\n * Angular-side replacement for the former <IntlayerEditorProvider> React component.\n *\n * Call **once** in your Angular application's bootstrap function or main module:\n *\n * ```typescript\n * import { bootstrapApplication } from '@angular/platform-browser';\n * import { AppComponent } from './app/app.component';\n * import { installIntlayerEditor } from 'angular-intlayer';\n *\n * bootstrapApplication(AppComponent).then(appRef => {\n *   installIntlayerEditor(appRef.injector);\n * });\n * ```\n */\nexport const installIntlayerEditor = (injector: Injector): void => {\n  /* ---------------------------------------------------------------------\n   * 1. Base providers – always on\n   * -------------------------------------------------------------------*/\n\n  installCommunicator(injector, {\n    postMessage,\n    allowedOrigins: [applicationURL, editorURL, cmsURL] as string[],\n  });\n  installEditorEnabled(injector);\n  installChangedContent(injector);\n  installDictionariesRecord(injector);\n  installEditedContent(injector);\n  installFocusDictionary(injector);\n};\n"],"mappings":"AACA,OAAO,mBAAmB;AAC1B,SAAS,6BAA6B;AACtC,SAAS,2BAA2B;AACpC,SAAS,iCAAiC;AAC1C,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,8BAA8B;AAEvC,MAAM,EAAE,OAAO,IAAI;AACnB,MAAM,EAAE,gBAAgB,WAAW,OAAO,IAAI,UAAU,CAAC;AAEzD,MAAM,cAAc,CAAC,SAAc;AACjC,MAAI,OAAO,WAAW,YAAa;AAEnC,QAAM,aAAa,OAAO,SAAS,OAAO;AAE1C,MAAI,CAAC,WAAY;AAEjB,MAAI,OAAO,eAAe,SAAS,GAAG;AACpC,WAAO,YAAY,MAAM,OAAO,cAAc;AAAA,EAChD;AAEA,MAAI,OAAO,UAAU,SAAS,GAAG;AAC/B,WAAO,OAAO,YAAY,MAAM,OAAO,SAAS;AAAA,EAClD;AAEA,MAAI,OAAO,OAAO,SAAS,GAAG;AAC5B,WAAO,OAAO,YAAY,MAAM,OAAO,MAAM;AAAA,EAC/C;AACF;AAiBO,MAAM,wBAAwB,CAAC,aAA6B;AAKjE,sBAAoB,UAAU;AAAA,IAC5B;AAAA,IACA,gBAAgB,CAAC,gBAAgB,WAAW,MAAM;AAAA,EACpD,CAAC;AACD,uBAAqB,QAAQ;AAC7B,wBAAsB,QAAQ;AAC9B,4BAA0B,QAAQ;AAClC,uBAAqB,QAAQ;AAC7B,yBAAuB,QAAQ;AACjC;","names":[]}

package/dist/esm/editor/useCrossFrameMessageListener.mjs

@@ -0,0 +1,59 @@
+"use client";
+import { DestroyRef, inject } from "@angular/core";
+import { compareUrls } from "@intlayer/editor";
+import { useCommunicator } from "./communicator.mjs";
+const subscribers = /* @__PURE__ */ new Map();
+let windowListenerAttached = false;
+function addSubscriber(key, cb) {
+  let set = subscribers.get(key);
+  if (!set) {
+    set = /* @__PURE__ */ new Set();
+    subscribers.set(key, set);
+  }
+  set.add(cb);
+}
+function removeSubscriber(key, cb) {
+  const set = subscribers.get(key);
+  if (!set) return;
+  set.delete(cb);
+  if (set.size === 0) subscribers.delete(key);
+}
+function ensureGlobalListener(allowedOrigins, selfId) {
+  if (windowListenerAttached) 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;
+}
+const useCrossFrameMessageListener = (key, onEventTriggered) => {
+  const { allowedOrigins, postMessage, senderId } = useCommunicator();
+  ensureGlobalListener(allowedOrigins, senderId);
+  if (onEventTriggered) {
+    addSubscriber(key, onEventTriggered);
+    try {
+      const destroyRef = inject(DestroyRef, { optional: true });
+      if (destroyRef) {
+        destroyRef.onDestroy(
+          () => removeSubscriber(key, onEventTriggered)
+        );
+      }
+    } catch {
+      console.warn(
+        "useCrossFrameMessageListener called outside injection context; cleanup may not be available."
+      );
+    }
+  }
+  const postMessageWrapper = (data) => {
+    postMessage({ type: key, data, senderId });
+  };
+  return postMessageWrapper;
+};
+export {
+  useCrossFrameMessageListener
+};
+//# sourceMappingURL=useCrossFrameMessageListener.mjs.map

package/dist/esm/editor/useCrossFrameMessageListener.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useCrossFrameMessageListener.ts"],"sourcesContent":["'use client';\n\nimport { DestroyRef, inject } from '@angular/core';\nimport { type MessageKey, compareUrls } from '@intlayer/editor';\nimport { useCommunicator } from './communicator';\n\n// ---------- module-level singletons ----------\ntype AnyFn = (data: unknown) => void;\n\n/** Map<key, Set<callback>> */\nconst subscribers = new Map<string, Set<AnyFn>>();\n\n/** True once we've attached the single window listener */\nlet windowListenerAttached = false;\n\n/** Helper to add/remove a callback for a key */\nfunction addSubscriber(key: string, cb: AnyFn) {\n  let set = subscribers.get(key);\n  if (!set) {\n    set = new Set();\n    subscribers.set(key, set);\n  }\n  set.add(cb);\n}\n\nfunction removeSubscriber(key: string, cb: AnyFn) {\n  const set = subscribers.get(key);\n  if (!set) return;\n  set.delete(cb);\n  if (set.size === 0) subscribers.delete(key);\n}\n\n/** The one global window listener */\nfunction ensureGlobalListener(\n  allowedOrigins: string[] | undefined,\n  selfId: string\n) {\n  if (windowListenerAttached) return;\n  window.addEventListener('message', (event) => {\n    const { type, data, senderId } = event.data ?? {};\n    if (!type) return; // guard malformed messages\n    if (senderId === selfId) return; // ignore my own\n\n    // origin check\n    if (\n      !allowedOrigins ||\n      allowedOrigins.includes('*') ||\n      allowedOrigins.some((o) => compareUrls(o, event.origin))\n    ) {\n      // broadcast to everyone interested in this key\n      subscribers.get(type)?.forEach((cb) => cb(data));\n    }\n  });\n  windowListenerAttached = true;\n}\n// ---------- end module-level code ----------\n\n/**\n * useCrossFrameMessageListener\n *\n * @template S - type of the message payload\n * @param key               message type we care about\n * @param onEventTriggered  optional callback when a matching message arrives\n * @returns postMessage(data?) helper scoped to this key\n */\nexport const useCrossFrameMessageListener = <S>(\n  key: `${MessageKey}` | `${MessageKey}/post` | `${MessageKey}/get`,\n  onEventTriggered?: (data: S) => void\n) => {\n  // Communicator is the same for everyone, so it's fine to call every time.\n  const { allowedOrigins, postMessage, senderId } = useCommunicator();\n\n  // --- 1. make sure the global listener exists ----\n  ensureGlobalListener(allowedOrigins, senderId);\n\n  // --- 2. register this caller's callback (if any) ---\n  if (onEventTriggered) {\n    addSubscriber(key, onEventTriggered as AnyFn);\n\n    // Use Angular's DestroyRef for cleanup instead of Vue's onScopeDispose\n    try {\n      const destroyRef = inject(DestroyRef, { optional: true });\n      if (destroyRef) {\n        destroyRef.onDestroy(() =>\n          removeSubscriber(key, onEventTriggered as AnyFn)\n        );\n      }\n    } catch {\n      // If called outside injection context, no cleanup available\n      console.warn(\n        'useCrossFrameMessageListener called outside injection context; ' +\n          'cleanup may not be available.'\n      );\n    }\n  }\n\n  // --- 3. return a wrapper that tags outgoing messages with our key ---\n  const postMessageWrapper = (data?: S) => {\n    postMessage({ type: key, data, senderId });\n  };\n\n  return postMessageWrapper;\n};\n"],"mappings":";AAEA,SAAS,YAAY,cAAc;AACnC,SAA0B,mBAAmB;AAC7C,SAAS,uBAAuB;AAMhC,MAAM,cAAc,oBAAI,IAAwB;AAGhD,IAAI,yBAAyB;AAG7B,SAAS,cAAc,KAAa,IAAW;AAC7C,MAAI,MAAM,YAAY,IAAI,GAAG;AAC7B,MAAI,CAAC,KAAK;AACR,UAAM,oBAAI,IAAI;AACd,gBAAY,IAAI,KAAK,GAAG;AAAA,EAC1B;AACA,MAAI,IAAI,EAAE;AACZ;AAEA,SAAS,iBAAiB,KAAa,IAAW;AAChD,QAAM,MAAM,YAAY,IAAI,GAAG;AAC/B,MAAI,CAAC,IAAK;AACV,MAAI,OAAO,EAAE;AACb,MAAI,IAAI,SAAS,EAAG,aAAY,OAAO,GAAG;AAC5C;AAGA,SAAS,qBACP,gBACA,QACA;AACA,MAAI,uBAAwB;AAC5B,SAAO,iBAAiB,WAAW,CAAC,UAAU;AAC5C,UAAM,EAAE,MAAM,MAAM,SAAS,IAAI,MAAM,QAAQ,CAAC;AAChD,QAAI,CAAC,KAAM;AACX,QAAI,aAAa,OAAQ;AAGzB,QACE,CAAC,kBACD,eAAe,SAAS,GAAG,KAC3B,eAAe,KAAK,CAAC,MAAM,YAAY,GAAG,MAAM,MAAM,CAAC,GACvD;AAEA,kBAAY,IAAI,IAAI,GAAG,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC;AAAA,IACjD;AAAA,EACF,CAAC;AACD,2BAAyB;AAC3B;AAWO,MAAM,+BAA+B,CAC1C,KACA,qBACG;AAEH,QAAM,EAAE,gBAAgB,aAAa,SAAS,IAAI,gBAAgB;AAGlE,uBAAqB,gBAAgB,QAAQ;AAG7C,MAAI,kBAAkB;AACpB,kBAAc,KAAK,gBAAyB;AAG5C,QAAI;AACF,YAAM,aAAa,OAAO,YAAY,EAAE,UAAU,KAAK,CAAC;AACxD,UAAI,YAAY;AACd,mBAAW;AAAA,UAAU,MACnB,iBAAiB,KAAK,gBAAyB;AAAA,QACjD;AAAA,MACF;AAAA,IACF,QAAQ;AAEN,cAAQ;AAAA,QACN;AAAA,MAEF;AAAA,IACF;AAAA,EACF;AAGA,QAAM,qBAAqB,CAAC,SAAa;AACvC,gBAAY,EAAE,MAAM,KAAK,MAAM,SAAS,CAAC;AAAA,EAC3C;AAEA,SAAO;AACT;","names":[]}

package/dist/esm/editor/useCrossFrameState.mjs

@@ -0,0 +1,71 @@
+import { signal } from "@angular/core";
+import { useCommunicator } from "./communicator.mjs";
+import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
+const crossFrameStateCache = /* @__PURE__ */ new Map();
+const resolveState = (state, prevState) => {
+  if (typeof state === "function") {
+    return state(prevState);
+  }
+  return state;
+};
+const toSerializable = (obj) => {
+  if (obj === null || obj === void 0) return obj;
+  return JSON.parse(JSON.stringify(obj));
+};
+const useCrossFrameState = (key, initialState, options = { emit: true, receive: true }) => {
+  if (crossFrameStateCache.has(key)) {
+    const { state, setState: setState2, postState: postState2 } = crossFrameStateCache.get(key);
+    return [state, setState2, postState2];
+  }
+  const { emit = true, receive = true } = options;
+  const stateSignal = signal(resolveState(initialState));
+  const { postMessage, senderId } = useCommunicator();
+  const broadcastState = (value) => {
+    if (!emit || typeof postMessage !== "function" || typeof value === "undefined")
+      return;
+    postMessage({
+      type: `${key}/post`,
+      data: value,
+      senderId
+    });
+  };
+  const setState = (valueOrUpdater) => {
+    const next = resolveState(valueOrUpdater, stateSignal());
+    const serialised = toSerializable(next);
+    stateSignal.set(serialised);
+    broadcastState(serialised);
+  };
+  const postState = () => {
+    if (typeof postMessage !== "function") return;
+    postMessage({
+      type: `${key}/post`,
+      data: stateSignal(),
+      senderId
+    });
+  };
+  broadcastState(stateSignal());
+  if (receive && typeof postMessage === "function" && typeof stateSignal() === "undefined") {
+    postMessage({ type: `${key}/get`, senderId });
+  }
+  useCrossFrameMessageListener(
+    `${key}/post`,
+    receive ? (data) => {
+      stateSignal.set(data);
+    } : void 0
+  );
+  const handleGetMessage = (_, originSenderId) => {
+    if (!emit) return;
+    if (originSenderId === senderId) return;
+    broadcastState(stateSignal());
+  };
+  useCrossFrameMessageListener(
+    `${key}/get`,
+    emit ? handleGetMessage : void 0
+  );
+  crossFrameStateCache.set(key, { state: stateSignal, setState, postState });
+  return [stateSignal, setState, postState];
+};
+export {
+  useCrossFrameState
+};
+//# sourceMappingURL=useCrossFrameState.mjs.map

package/dist/esm/editor/useCrossFrameState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useCrossFrameState.ts"],"sourcesContent":["import { signal, Signal } from '@angular/core';\nimport { type MessageKey } from '@intlayer/editor';\nimport { useCommunicator } from './communicator';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\nexport type CrossFrameStateOptions = {\n  /** Whether to broadcast state changes to other instances (default: true) */\n  emit?: boolean;\n  /** Whether to listen for state updates from other instances (default: true) */\n  receive?: boolean;\n};\n\nconst crossFrameStateCache = new Map<\n  string,\n  {\n    state: Signal<any>;\n    setState: (v: any | ((prev: any) => any)) => void;\n    postState: () => void;\n  }\n>();\n\n/**\n * Utility to resolve either a value or an updater function (mirrors React's `setState`).\n */\nconst resolveState = <S>(\n  state: S | ((prev?: S) => S) | undefined,\n  prevState?: S\n): S | undefined => {\n  if (typeof state === 'function') {\n    return (state as (prev?: S) => S)(prevState);\n  }\n  return state as S;\n};\n\n/**\n * Creates a plain object copy that can be safely serialized\n * for postMessage communication\n */\nconst toSerializable = <T>(obj: T): T => {\n  if (obj === null || obj === undefined) return obj;\n  // Using parse/stringify for a quick deep clone to remove reactivity\n  return JSON.parse(JSON.stringify(obj));\n};\n\n/**\n * Angular replacement for Vue's cross-frame state composable.\n * It synchronises a reactive value across frames/windows via the `postMessage` API.\n *\n * @template S The type of the state being synchronised.\n * @param key          Unique key identifying this state channel.\n * @param initialState Initial value (or lazy factory) for the state.\n * @param options      Control flags for emitting/receiving updates.\n *\n * @returns `[stateSignal, setState, postState]`\n *          - `stateSignal` – Angular `Signal<S | undefined>` holding the current state.\n *          - `setState`    – Setter with the same API as React's `setState`.\n *          - `postState`   – Manually broadcast the current state (useful after mutations outside `setState`).\n */\nexport const useCrossFrameState = <S>(\n  key: `${MessageKey}`,\n  initialState?: S | (() => S),\n  options: CrossFrameStateOptions = { emit: true, receive: true }\n): [\n  Signal<S | undefined>,\n  (v: S | ((prev: S | undefined) => S)) => void,\n  () => void,\n] => {\n  if (crossFrameStateCache.has(key)) {\n    // Return the existing instance\n    const { state, setState, postState } = crossFrameStateCache.get(key)!;\n    return [state, setState, postState];\n  }\n\n  const { emit = true, receive = true } = options;\n\n  /**\n   * Internal reactive state using Angular signals.\n   * We resolve the initial value here to avoid one extra render (same idea as in the React version).\n   */\n  const stateSignal = signal<S | undefined>(resolveState<S>(initialState));\n\n  // Get communicator within injection context\n  const { postMessage, senderId } = useCommunicator();\n\n  /**\n   * Broadcast the given value if emitting is allowed and the communicator is ready.\n   */\n  const broadcastState = (value: S | undefined) => {\n    if (\n      !emit ||\n      typeof postMessage !== 'function' ||\n      typeof value === 'undefined'\n    )\n      return;\n    postMessage({\n      type: `${key}/post`,\n      data: value,\n      senderId,\n    });\n  };\n\n  /**\n   * Setter that mirrors React's `setState` signature (supports value or updater fn).\n   */\n  const setState = (valueOrUpdater: S | ((prev: S | undefined) => S)) => {\n    const next = resolveState<S>(valueOrUpdater as any, stateSignal());\n    const serialised = toSerializable(next);\n    stateSignal.set(serialised);\n    broadcastState(serialised);\n  };\n\n  /**\n   * Manually broadcast the current state to peers.\n   */\n  const postState = () => {\n    if (typeof postMessage !== 'function') return;\n    postMessage({\n      type: `${key}/post`,\n      data: stateSignal(),\n      senderId,\n    });\n  };\n\n  // Emit the initial state (if any) right away so that peers can pick it up.\n  broadcastState(stateSignal());\n\n  // If we are in receive mode but have no state yet, ask peers for theirs.\n  if (\n    receive &&\n    typeof postMessage === 'function' &&\n    typeof stateSignal() === 'undefined'\n  ) {\n    postMessage({ type: `${key}/get`, senderId });\n  }\n\n  /* ───────────────────── Incoming messages ───────────────────── */\n\n  // 1. Updates posted by other frames\n  useCrossFrameMessageListener<S>(\n    `${key}/post`,\n    receive\n      ? (data) => {\n          stateSignal.set(data);\n        }\n      : undefined\n  );\n\n  // 2. Requests from peers asking for our current value\n  const handleGetMessage = (_: unknown, originSenderId?: string) => {\n    if (!emit) return;\n    if (originSenderId === senderId) return; // Don't respond to our own request\n    broadcastState(stateSignal());\n  };\n\n  useCrossFrameMessageListener(\n    `${key}/get`,\n    emit ? handleGetMessage : undefined\n  );\n\n  // Cache this instance\n  crossFrameStateCache.set(key, { state: stateSignal, setState, postState });\n\n  return [stateSignal as Signal<S | undefined>, setState, postState];\n};\n"],"mappings":"AAAA,SAAS,cAAsB;AAE/B,SAAS,uBAAuB;AAChC,SAAS,oCAAoC;AAS7C,MAAM,uBAAuB,oBAAI,IAO/B;AAKF,MAAM,eAAe,CACnB,OACA,cACkB;AAClB,MAAI,OAAO,UAAU,YAAY;AAC/B,WAAQ,MAA0B,SAAS;AAAA,EAC7C;AACA,SAAO;AACT;AAMA,MAAM,iBAAiB,CAAI,QAAc;AACvC,MAAI,QAAQ,QAAQ,QAAQ,OAAW,QAAO;AAE9C,SAAO,KAAK,MAAM,KAAK,UAAU,GAAG,CAAC;AACvC;AAgBO,MAAM,qBAAqB,CAChC,KACA,cACA,UAAkC,EAAE,MAAM,MAAM,SAAS,KAAK,MAK3D;AACH,MAAI,qBAAqB,IAAI,GAAG,GAAG;AAEjC,UAAM,EAAE,OAAO,UAAAA,WAAU,WAAAC,WAAU,IAAI,qBAAqB,IAAI,GAAG;AACnE,WAAO,CAAC,OAAOD,WAAUC,UAAS;AAAA,EACpC;AAEA,QAAM,EAAE,OAAO,MAAM,UAAU,KAAK,IAAI;AAMxC,QAAM,cAAc,OAAsB,aAAgB,YAAY,CAAC;AAGvE,QAAM,EAAE,aAAa,SAAS,IAAI,gBAAgB;AAKlD,QAAM,iBAAiB,CAAC,UAAyB;AAC/C,QACE,CAAC,QACD,OAAO,gBAAgB,cACvB,OAAO,UAAU;AAEjB;AACF,gBAAY;AAAA,MACV,MAAM,GAAG,GAAG;AAAA,MACZ,MAAM;AAAA,MACN;AAAA,IACF,CAAC;AAAA,EACH;AAKA,QAAM,WAAW,CAAC,mBAAqD;AACrE,UAAM,OAAO,aAAgB,gBAAuB,YAAY,CAAC;AACjE,UAAM,aAAa,eAAe,IAAI;AACtC,gBAAY,IAAI,UAAU;AAC1B,mBAAe,UAAU;AAAA,EAC3B;AAKA,QAAM,YAAY,MAAM;AACtB,QAAI,OAAO,gBAAgB,WAAY;AACvC,gBAAY;AAAA,MACV,MAAM,GAAG,GAAG;AAAA,MACZ,MAAM,YAAY;AAAA,MAClB;AAAA,IACF,CAAC;AAAA,EACH;AAGA,iBAAe,YAAY,CAAC;AAG5B,MACE,WACA,OAAO,gBAAgB,cACvB,OAAO,YAAY,MAAM,aACzB;AACA,gBAAY,EAAE,MAAM,GAAG,GAAG,QAAQ,SAAS,CAAC;AAAA,EAC9C;AAKA;AAAA,IACE,GAAG,GAAG;AAAA,IACN,UACI,CAAC,SAAS;AACR,kBAAY,IAAI,IAAI;AAAA,IACtB,IACA;AAAA,EACN;AAGA,QAAM,mBAAmB,CAAC,GAAY,mBAA4B;AAChE,QAAI,CAAC,KAAM;AACX,QAAI,mBAAmB,SAAU;AACjC,mBAAe,YAAY,CAAC;AAAA,EAC9B;AAEA;AAAA,IACE,GAAG,GAAG;AAAA,IACN,OAAO,mBAAmB;AAAA,EAC5B;AAGA,uBAAqB,IAAI,KAAK,EAAE,OAAO,aAAa,UAAU,UAAU,CAAC;AAEzE,SAAO,CAAC,aAAsC,UAAU,SAAS;AACnE;","names":["setState","postState"]}

package/dist/esm/editor/useCrossURLPathState.mjs

@@ -0,0 +1,47 @@
+import { DestroyRef, inject } from "@angular/core";
+import { MessageKey } from "@intlayer/editor";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+const useCrossURLPathState = (initial, opts) => useCrossFrameState(MessageKey.INTLAYER_URL_CHANGE, initial, opts);
+const useCrossURLPathSetter = (initial) => {
+  const [state, setState] = useCrossURLPathState(initial, {
+    emit: true,
+    receive: false
+  });
+  let originalPushState;
+  let originalReplaceState;
+  const update = () => setState(window.location.pathname);
+  try {
+    const destroyRef = inject(DestroyRef, { optional: true });
+    if (destroyRef && typeof window !== "undefined") {
+      originalPushState = history.pushState;
+      originalReplaceState = history.replaceState;
+      const wrap = (fn) => (...args) => {
+        fn.apply(history, args);
+        window.dispatchEvent(new Event("locationchange"));
+      };
+      history.pushState = wrap(originalPushState);
+      history.replaceState = wrap(originalReplaceState);
+      window.addEventListener("locationchange", update);
+      window.addEventListener("popstate", update);
+      window.addEventListener("hashchange", update);
+      update();
+      destroyRef.onDestroy(() => {
+        window.removeEventListener("locationchange", update);
+        window.removeEventListener("popstate", update);
+        window.removeEventListener("hashchange", update);
+        if (originalPushState) history.pushState = originalPushState;
+        if (originalReplaceState) history.replaceState = originalReplaceState;
+      });
+    }
+  } catch {
+    console.warn(
+      "useCrossURLPathSetter called outside injection context; URL path synchronization may not be available."
+    );
+  }
+  return [state, setState];
+};
+export {
+  useCrossURLPathSetter,
+  useCrossURLPathState
+};
+//# sourceMappingURL=useCrossURLPathState.mjs.map

package/dist/esm/editor/useCrossURLPathState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useCrossURLPathState.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core';\nimport { MessageKey } from '@intlayer/editor';\nimport { useCrossFrameState } from './useCrossFrameState';\n\n/**\n * Hook to create and manage a cross-frame synchronized URL path state\n * @param initial - The initial URL path\n * @param opts - Options for controlling emit and receive behavior\n * @returns A tuple containing [state signal, setState function, forceSync function]\n */\nexport const useCrossURLPathState = (\n  initial?: string,\n  opts?: Parameters<typeof useCrossFrameState>[2]\n) => useCrossFrameState<string>(MessageKey.INTLAYER_URL_CHANGE, initial, opts);\n\n/**\n * Hook for host applications to push URL path changes into the shared state\n * This also monkey patches history methods to capture navigation events\n * @param initial - The initial URL path\n * @returns A tuple containing [state signal, setState function]\n */\nexport const useCrossURLPathSetter = (initial?: string) => {\n  const [state, setState] = useCrossURLPathState(initial, {\n    emit: true,\n    receive: false,\n  });\n\n  // Original history methods\n  let originalPushState: typeof history.pushState;\n  let originalReplaceState: typeof history.replaceState;\n\n  // Function to update state with current pathname\n  const update = () => setState(window.location.pathname);\n\n  // Use Angular's DestroyRef for cleanup instead of Vue lifecycle hooks\n  try {\n    const destroyRef = inject(DestroyRef, { optional: true });\n\n    if (destroyRef && typeof window !== 'undefined') {\n      // Save original methods\n      originalPushState = history.pushState;\n      originalReplaceState = history.replaceState;\n\n      /**\n       * Wraps a history function to dispatch a custom event when called\n       * @param fn - The history function to wrap\n       * @returns The wrapped function\n       */\n      const wrap =\n        (fn: typeof history.pushState) =>\n        (...args: Parameters<typeof history.pushState>) => {\n          fn.apply(history, args);\n          window.dispatchEvent(new Event('locationchange'));\n        };\n\n      // Patch history methods\n      history.pushState = wrap(originalPushState);\n      history.replaceState = wrap(originalReplaceState);\n\n      // Add event listeners\n      window.addEventListener('locationchange', update);\n      window.addEventListener('popstate', update);\n      window.addEventListener('hashchange', update);\n\n      // Initialize immediately\n      update();\n\n      // Clean up on destroy\n      destroyRef.onDestroy(() => {\n        window.removeEventListener('locationchange', update);\n        window.removeEventListener('popstate', update);\n        window.removeEventListener('hashchange', update);\n\n        // Restore original history methods\n        if (originalPushState) history.pushState = originalPushState;\n        if (originalReplaceState) history.replaceState = originalReplaceState;\n      });\n    }\n  } catch {\n    console.warn(\n      'useCrossURLPathSetter called outside injection context; ' +\n        'URL path synchronization may not be available.'\n    );\n  }\n\n  return [state, setState] as const;\n};\n"],"mappings":"AAAA,SAAS,YAAY,cAAc;AACnC,SAAS,kBAAkB;AAC3B,SAAS,0BAA0B;AAQ5B,MAAM,uBAAuB,CAClC,SACA,SACG,mBAA2B,WAAW,qBAAqB,SAAS,IAAI;AAQtE,MAAM,wBAAwB,CAAC,YAAqB;AACzD,QAAM,CAAC,OAAO,QAAQ,IAAI,qBAAqB,SAAS;AAAA,IACtD,MAAM;AAAA,IACN,SAAS;AAAA,EACX,CAAC;AAGD,MAAI;AACJ,MAAI;AAGJ,QAAM,SAAS,MAAM,SAAS,OAAO,SAAS,QAAQ;AAGtD,MAAI;AACF,UAAM,aAAa,OAAO,YAAY,EAAE,UAAU,KAAK,CAAC;AAExD,QAAI,cAAc,OAAO,WAAW,aAAa;AAE/C,0BAAoB,QAAQ;AAC5B,6BAAuB,QAAQ;AAO/B,YAAM,OACJ,CAAC,OACD,IAAI,SAA+C;AACjD,WAAG,MAAM,SAAS,IAAI;AACtB,eAAO,cAAc,IAAI,MAAM,gBAAgB,CAAC;AAAA,MAClD;AAGF,cAAQ,YAAY,KAAK,iBAAiB;AAC1C,cAAQ,eAAe,KAAK,oBAAoB;AAGhD,aAAO,iBAAiB,kBAAkB,MAAM;AAChD,aAAO,iBAAiB,YAAY,MAAM;AAC1C,aAAO,iBAAiB,cAAc,MAAM;AAG5C,aAAO;AAGP,iBAAW,UAAU,MAAM;AACzB,eAAO,oBAAoB,kBAAkB,MAAM;AACnD,eAAO,oBAAoB,YAAY,MAAM;AAC7C,eAAO,oBAAoB,cAAc,MAAM;AAG/C,YAAI,kBAAmB,SAAQ,YAAY;AAC3C,YAAI,qBAAsB,SAAQ,eAAe;AAAA,MACnD,CAAC;AAAA,IACH;AAAA,EACF,QAAQ;AACN,YAAQ;AAAA,MACN;AAAA,IAEF;AAAA,EACF;AAEA,SAAO,CAAC,OAAO,QAAQ;AACzB;","names":[]}

package/dist/esm/editor/useEditedContentRenderer.mjs

@@ -0,0 +1,37 @@
+import {
+  computed,
+  inject,
+  Injectable,
+  InjectionToken
+} from "@angular/core";
+const EDITED_CONTENT_ACTIONS_TOKEN = new InjectionToken("editedContentActions");
+@Injectable({
+  providedIn: "root"
+})
+class EditedContentRendererService {
+  /**
+   * Mirrors the React hook one-for-one.
+   */
+  useEditedContentRenderer(dictionaryKey, keyPath, fallback) {
+    const editedContentContext = inject(EDITED_CONTENT_ACTIONS_TOKEN, {
+      optional: true
+    });
+    return computed(() => {
+      const edited = editedContentContext?.getEditedContentValue(
+        dictionaryKey,
+        keyPath
+      );
+      return edited ?? fallback;
+    });
+  }
+}
+const useEditedContentRenderer = (dictionaryKey, keyPath, fallback) => {
+  const service = inject(EditedContentRendererService);
+  return service.useEditedContentRenderer(dictionaryKey, keyPath, fallback);
+};
+export {
+  EDITED_CONTENT_ACTIONS_TOKEN,
+  EditedContentRendererService,
+  useEditedContentRenderer
+};
+//# sourceMappingURL=useEditedContentRenderer.mjs.map

package/dist/esm/editor/useEditedContentRenderer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useEditedContentRenderer.ts"],"sourcesContent":["import {\n  computed,\n  inject,\n  Injectable,\n  InjectionToken,\n  Signal,\n} from '@angular/core';\nimport { type KeyPath } from '@intlayer/core';\n\nexport interface EditedContentActions {\n  getEditedContentValue(dictionaryKey: string, keyPath: KeyPath[]): unknown;\n}\n\nexport const EDITED_CONTENT_ACTIONS_TOKEN =\n  new InjectionToken<EditedContentActions | null>('editedContentActions');\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EditedContentRendererService {\n  /**\n   * Mirrors the React hook one-for-one.\n   */\n  useEditedContentRenderer(\n    dictionaryKey: string,\n    keyPath: KeyPath[],\n    fallback: unknown\n  ): Signal<unknown> {\n    const editedContentContext = inject(EDITED_CONTENT_ACTIONS_TOKEN, {\n      optional: true,\n    });\n\n    return computed(() => {\n      const edited = editedContentContext?.getEditedContentValue(\n        dictionaryKey,\n        keyPath\n      ) as string | undefined;\n\n      return edited ?? fallback;\n    });\n  }\n}\n\n/**\n * Standalone function that can be used like the Vue composable\n */\nexport const useEditedContentRenderer = (\n  dictionaryKey: string,\n  keyPath: KeyPath[],\n  fallback: unknown\n): Signal<unknown> => {\n  const service = inject(EditedContentRendererService);\n  return service.useEditedContentRenderer(dictionaryKey, keyPath, fallback);\n};\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAOA,MAAM,+BACX,IAAI,eAA4C,sBAAsB;AAExE,CAAC,WAAW;AAAA,EACV,YAAY;AACd,CAAC;AACM,MAAM,6BAA6B;AAAA;AAAA;AAAA;AAAA,EAIxC,yBACE,eACA,SACA,UACiB;AACjB,UAAM,uBAAuB,OAAO,8BAA8B;AAAA,MAChE,UAAU;AAAA,IACZ,CAAC;AAED,WAAO,SAAS,MAAM;AACpB,YAAM,SAAS,sBAAsB;AAAA,QACnC;AAAA,QACA;AAAA,MACF;AAEA,aAAO,UAAU;AAAA,IACnB,CAAC;AAAA,EACH;AACF;AAKO,MAAM,2BAA2B,CACtC,eACA,SACA,aACoB;AACpB,QAAM,UAAU,OAAO,4BAA4B;AACnD,SAAO,QAAQ,yBAAyB,eAAe,SAAS,QAAQ;AAC1E;","names":[]}

package/dist/esm/editor/useEditor.mjs

@@ -0,0 +1,22 @@
+import { useConfiguration } from "./configuration.mjs";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useDictionariesRecord } from "./dictionariesRecord.mjs";
+import { useEditorEnabled } from "./editorEnabled.mjs";
+import { useEditorLocale } from "./editorLocale.mjs";
+import { useFocusDictionary } from "./focusDictionary.mjs";
+import { useCrossURLPathSetter } from "./useCrossURLPathState.mjs";
+import { useIframeClickMerger } from "./useIframeClickInterceptor.mjs";
+const useEditor = createSharedComposable(() => {
+  useConfiguration();
+  useEditorEnabled();
+  useFocusDictionary();
+  useIframeClickMerger();
+  useCrossURLPathSetter();
+  useEditorLocale();
+  useDictionariesRecord();
+  useEditorLocale();
+});
+export {
+  useEditor
+};
+//# sourceMappingURL=useEditor.mjs.map

package/dist/esm/editor/useEditor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useEditor.ts"],"sourcesContent":["import { useConfiguration } from './configuration';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useDictionariesRecord } from './dictionariesRecord';\nimport { useEditorEnabled } from './editorEnabled';\nimport { useEditorLocale } from './editorLocale';\nimport { useFocusDictionary } from './focusDictionary';\nimport { useCrossURLPathSetter } from './useCrossURLPathState';\nimport { useIframeClickMerger } from './useIframeClickInterceptor';\n\nexport const useEditor = createSharedComposable(() => {\n  useConfiguration();\n  useEditorEnabled();\n  useFocusDictionary();\n  useIframeClickMerger();\n  useCrossURLPathSetter();\n  useEditorLocale();\n  useDictionariesRecord();\n  useEditorLocale();\n});\n"],"mappings":"AAAA,SAAS,wBAAwB;AACjC,SAAS,8BAA8B;AACvC,SAAS,6BAA6B;AACtC,SAAS,wBAAwB;AACjC,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,6BAA6B;AACtC,SAAS,4BAA4B;AAE9B,MAAM,YAAY,uBAAuB,MAAM;AACpD,mBAAiB;AACjB,mBAAiB;AACjB,qBAAmB;AACnB,uBAAqB;AACrB,wBAAsB;AACtB,kBAAgB;AAChB,wBAAsB;AACtB,kBAAgB;AAClB,CAAC;","names":[]}

package/dist/esm/editor/useIframeClickInterceptor.mjs

@@ -0,0 +1,37 @@
+import { DestroyRef, inject } from "@angular/core";
+import { MessageKey, mergeIframeClick } from "@intlayer/editor";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
+const useIframeClickInterceptor = createSharedComposable(() => {
+  const postMessage = useCrossFrameMessageListener(
+    MessageKey.INTLAYER_IFRAME_CLICKED
+  );
+  const handler = () => {
+    postMessage();
+  };
+  try {
+    const destroyRef = inject(DestroyRef, { optional: true });
+    if (destroyRef && typeof window !== "undefined") {
+      window.addEventListener("mousedown", handler);
+      destroyRef.onDestroy(
+        () => window.removeEventListener("mousedown", handler)
+      );
+    }
+  } catch {
+    console.warn(
+      "useIframeClickInterceptor called outside injection context; event listener setup may not be available."
+    );
+  }
+});
+const useIframeClickMerger = createSharedComposable(() => {
+  useIframeClickInterceptor();
+  useCrossFrameMessageListener(
+    MessageKey.INTLAYER_IFRAME_CLICKED,
+    mergeIframeClick
+  );
+});
+export {
+  useIframeClickInterceptor,
+  useIframeClickMerger
+};
+//# sourceMappingURL=useIframeClickInterceptor.mjs.map

package/dist/esm/editor/useIframeClickInterceptor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useIframeClickInterceptor.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core';\nimport { MessageKey, mergeIframeClick } from '@intlayer/editor';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\n/* ─────────────────────────────────────────────\n   1.  \"Interceptor\" – send a postMessage when\n       the editor iframe itself is clicked.\n────────────────────────────────────────────── */\n/**\n * Hook that intercepts clicks in the iframe and sends them to the parent window\n * This allows the parent window to know when the iframe is clicked\n */\nexport const useIframeClickInterceptor = createSharedComposable(() => {\n  const postMessage = useCrossFrameMessageListener<undefined>(\n    MessageKey.INTLAYER_IFRAME_CLICKED\n  );\n\n  const handler = () => {\n    postMessage();\n  };\n\n  // Use Angular's DestroyRef for cleanup instead of Vue's lifecycle hooks\n  try {\n    const destroyRef = inject(DestroyRef, { optional: true });\n\n    if (destroyRef && typeof window !== 'undefined') {\n      // Set up event listener immediately\n      window.addEventListener('mousedown', handler);\n\n      // Clean up on destroy\n      destroyRef.onDestroy(() =>\n        window.removeEventListener('mousedown', handler)\n      );\n    }\n  } catch {\n    console.warn(\n      'useIframeClickInterceptor called outside injection context; ' +\n        'event listener setup may not be available.'\n    );\n  }\n});\n\n/**\n * Hook for the parent window to listen for iframe clicks and merge them\n * This makes iframe clicks behave as if they happened in the parent window\n */\nexport const useIframeClickMerger = createSharedComposable(() => {\n  useIframeClickInterceptor();\n\n  useCrossFrameMessageListener<MessageEvent>(\n    MessageKey.INTLAYER_IFRAME_CLICKED,\n    mergeIframeClick\n  );\n});\n"],"mappings":"AAAA,SAAS,YAAY,cAAc;AACnC,SAAS,YAAY,wBAAwB;AAC7C,SAAS,8BAA8B;AACvC,SAAS,oCAAoC;AAUtC,MAAM,4BAA4B,uBAAuB,MAAM;AACpE,QAAM,cAAc;AAAA,IAClB,WAAW;AAAA,EACb;AAEA,QAAM,UAAU,MAAM;AACpB,gBAAY;AAAA,EACd;AAGA,MAAI;AACF,UAAM,aAAa,OAAO,YAAY,EAAE,UAAU,KAAK,CAAC;AAExD,QAAI,cAAc,OAAO,WAAW,aAAa;AAE/C,aAAO,iBAAiB,aAAa,OAAO;AAG5C,iBAAW;AAAA,QAAU,MACnB,OAAO,oBAAoB,aAAa,OAAO;AAAA,MACjD;AAAA,IACF;AAAA,EACF,QAAQ;AACN,YAAQ;AAAA,MACN;AAAA,IAEF;AAAA,EACF;AACF,CAAC;AAMM,MAAM,uBAAuB,uBAAuB,MAAM;AAC/D,4BAA0B;AAE1B;AAAA,IACE,WAAW;AAAA,IACX;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/esm/getDictionary.mjs

@@ -1,4 +1,22 @@
-import { getDictionary } from "./client/getDictionary.mjs";
+import {
+  getDictionary as getDictionaryCore
+} from "@intlayer/core";
+import {
+  intlayerNodePlugins,
+  markdownPlugin
+} from "./plugins.mjs";
+const getDictionary = (dictionary, locale, additionalPlugins) => {
+  const plugins = [
+    intlayerNodePlugins,
+    markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return getDictionaryCore(
+    dictionary,
+    locale,
+    plugins
+  );
+};
 export {
   getDictionary
 };

package/dist/esm/getDictionary.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/getDictionary.ts"],"sourcesContent":["export { getDictionary } from './client/getDictionary';\n"],"mappings":"AAAA,SAAS,qBAAqB;","names":[]}
+{"version":3,"sources":["../../src/getDictionary.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config/client';\nimport {\n  Dictionary,\n  Plugins,\n  getDictionary as getDictionaryCore,\n} from '@intlayer/core';\nimport {\n  DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n} from './plugins';\n\nexport const getDictionary = <\n  T extends Dictionary,\n  L extends LocalesValues = Locales,\n>(\n  dictionary: T,\n  locale?: L,\n  additionalPlugins?: Plugins[]\n) => {\n  const plugins: Plugins[] = [\n    intlayerNodePlugins,\n    markdownPlugin,\n    ...(additionalPlugins ?? []),\n  ];\n\n  return getDictionaryCore(\n    dictionary,\n    locale,\n    plugins\n  ) as any as DeepTransformContent<T['content']>;\n};\n"],"mappings":"AACA;AAAA,EAGE,iBAAiB;AAAA,OACZ;AACP;AAAA,EAEE;AAAA,EACA;AAAA,OACK;AAEA,MAAM,gBAAgB,CAI3B,YACA,QACA,sBACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,GAAI,qBAAqB,CAAC;AAAA,EAC5B;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/esm/getIntlayer.mjs

@@ -1,5 +1,17 @@
-const getIntlayer = (dictionary, locale, additionalPlugins) => {
-  return dictionary.content || dictionary;
+import {
+  getIntlayer as getIntlayerCore
+} from "@intlayer/core";
+import {
+  intlayerNodePlugins,
+  markdownPlugin
+} from "./plugins.mjs";
+const getIntlayer = (key, locale, additionalPlugins) => {
+  const plugins = [
+    intlayerNodePlugins,
+    markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return getIntlayerCore(key, locale, plugins);
 };
 export {
   getIntlayer

package/dist/esm/getIntlayer.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import type { Locales, LocalesValues } from '@intlayer/config';\nimport type { Dictionary, Plugins } from '@intlayer/core';\n\n/**\n * Function to get the content of a dictionary for Angular applications\n */\nexport const getIntlayer = <\n  T extends Dictionary,\n  L extends LocalesValues = Locales,\n>(\n  dictionary: T,\n  locale: L,\n  additionalPlugins?: Plugins[]\n): any => {\n  // Simplified implementation to avoid type complexity\n  return dictionary.content || dictionary;\n};\n"],"mappings":"AAMO,MAAM,cAAc,CAIzB,YACA,QACA,sBACQ;AAER,SAAO,WAAW,WAAW;AAC/B;","names":[]}
+{"version":3,"sources":["../../src/getIntlayer.ts"],"sourcesContent":["import {\n  DictionaryKeys,\n  getIntlayer as getIntlayerCore,\n  Plugins,\n} from '@intlayer/core';\n// @ts-ignore intlayer declared for module augmentation\nimport type { IntlayerDictionaryTypesConnector, LocalesValues } from 'intlayer';\nimport {\n  DeepTransformContent,\n  intlayerNodePlugins,\n  markdownPlugin,\n} from './plugins';\n\nexport const getIntlayer = <T extends DictionaryKeys, L extends LocalesValues>(\n  key: T,\n  locale?: L,\n  additionalPlugins?: Plugins[]\n) => {\n  const plugins: Plugins[] = [\n    intlayerNodePlugins,\n    markdownPlugin,\n    ...(additionalPlugins ?? []),\n  ];\n\n  return getIntlayerCore(key, locale, plugins) as any as DeepTransformContent<\n    IntlayerDictionaryTypesConnector[T]['content']\n  >;\n};\n"],"mappings":"AAAA;AAAA,EAEE,eAAe;AAAA,OAEV;AAGP;AAAA,EAEE;AAAA,EACA;AAAA,OACK;AAEA,MAAM,cAAc,CACzB,KACA,QACA,sBACG;AACH,QAAM,UAAqB;AAAA,IACzB;AAAA,IACA;AAAA,IACA,GAAI,qBAAqB,CAAC;AAAA,EAC5B;AAEA,SAAO,gBAAgB,KAAK,QAAQ,OAAO;AAG7C;","names":[]}

package/dist/esm/markdown/index.mjs

@@ -1,11 +1,2 @@
-const renderMarkdown = (content) => {
-  return content;
-};
-const MarkdownModule = {
-  renderMarkdown
-};
-export {
-  MarkdownModule,
-  renderMarkdown
-};
+export * from "./installIntlayerMarkdown.mjs";
 //# sourceMappingURL=index.mjs.map

package/dist/esm/markdown/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/markdown/index.ts"],"sourcesContent":["// Basic markdown support for Angular\n// This could be extended with Angular-specific markdown components\n\nexport const renderMarkdown = (content: string): string => {\n  // Basic implementation - in a real app this might use a markdown library\n  return content;\n};\n\nexport const MarkdownModule = {\n  renderMarkdown,\n};\n"],"mappings":"AAGO,MAAM,iBAAiB,CAAC,YAA4B;AAEzD,SAAO;AACT;AAEO,MAAM,iBAAiB;AAAA,EAC5B;AACF;","names":[]}
+{"version":3,"sources":["../../../src/markdown/index.ts"],"sourcesContent":["export * from './installIntlayerMarkdown';\n"],"mappings":"AAAA,cAAc;","names":[]}

package/dist/esm/markdown/installIntlayerMarkdown.mjs

@@ -0,0 +1,39 @@
+import { inject, Injectable, InjectionToken } from "@angular/core";
+const INTLAYER_MARKDOWN_TOKEN = new InjectionToken("intlayerMarkdown");
+const defaultMarkdownRenderer = (markdown) => markdown;
+const createIntlayerMarkdownProvider = (renderMarkdown = defaultMarkdownRenderer) => ({
+  provide: INTLAYER_MARKDOWN_TOKEN,
+  useValue: {
+    renderMarkdown
+  }
+});
+@Injectable({
+  providedIn: "root"
+})
+class IntlayerMarkdownService {
+  markdownProvider = inject(INTLAYER_MARKDOWN_TOKEN, {
+    optional: true
+  });
+  renderMarkdown(markdown) {
+    if (!this.markdownProvider) {
+      return markdown;
+    }
+    return this.markdownProvider.renderMarkdown(markdown);
+  }
+}
+const useMarkdown = () => {
+  const markdownProvider = inject(INTLAYER_MARKDOWN_TOKEN, { optional: true });
+  if (!markdownProvider) {
+    return {
+      renderMarkdown: defaultMarkdownRenderer
+    };
+  }
+  return markdownProvider;
+};
+export {
+  INTLAYER_MARKDOWN_TOKEN,
+  IntlayerMarkdownService,
+  createIntlayerMarkdownProvider,
+  useMarkdown
+};
+//# sourceMappingURL=installIntlayerMarkdown.mjs.map

package/dist/esm/markdown/installIntlayerMarkdown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/markdown/installIntlayerMarkdown.ts"],"sourcesContent":["import { inject, Injectable, InjectionToken, TemplateRef } from '@angular/core';\n\nexport const INTLAYER_MARKDOWN_TOKEN =\n  new InjectionToken<IntlayerMarkdownProvider>('intlayerMarkdown');\n\ntype RenderMarkdownFunction = (markdown: string) => string | TemplateRef<any>;\n\nexport type IntlayerMarkdownProvider = {\n  renderMarkdown: RenderMarkdownFunction;\n};\n\n/**\n * Default markdown renderer that returns the markdown as is\n */\nconst defaultMarkdownRenderer: RenderMarkdownFunction = (markdown: string) =>\n  markdown;\n\n/**\n * Create IntlayerMarkdown provider configuration\n */\nexport const createIntlayerMarkdownProvider = (\n  renderMarkdown: RenderMarkdownFunction = defaultMarkdownRenderer\n) => ({\n  provide: INTLAYER_MARKDOWN_TOKEN,\n  useValue: {\n    renderMarkdown,\n  } as IntlayerMarkdownProvider,\n});\n\n/**\n * Injectable service for markdown rendering\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class IntlayerMarkdownService {\n  private markdownProvider = inject(INTLAYER_MARKDOWN_TOKEN, {\n    optional: true,\n  });\n\n  renderMarkdown(markdown: string): string | TemplateRef<any> {\n    if (!this.markdownProvider) {\n      return markdown; // Fallback to returning markdown as is\n    }\n    return this.markdownProvider.renderMarkdown(markdown);\n  }\n}\n\n/**\n * Function to inject markdown provider\n */\nexport const useMarkdown = (): IntlayerMarkdownProvider => {\n  const markdownProvider = inject(INTLAYER_MARKDOWN_TOKEN, { optional: true });\n\n  if (!markdownProvider) {\n    return {\n      renderMarkdown: defaultMarkdownRenderer,\n    };\n  }\n\n  return markdownProvider;\n};\n"],"mappings":"AAAA,SAAS,QAAQ,YAAY,sBAAmC;AAEzD,MAAM,0BACX,IAAI,eAAyC,kBAAkB;AAWjE,MAAM,0BAAkD,CAAC,aACvD;AAKK,MAAM,iCAAiC,CAC5C,iBAAyC,6BACrC;AAAA,EACJ,SAAS;AAAA,EACT,UAAU;AAAA,IACR;AAAA,EACF;AACF;AAKA,CAAC,WAAW;AAAA,EACV,YAAY;AACd,CAAC;AACM,MAAM,wBAAwB;AAAA,EAC3B,mBAAmB,OAAO,yBAAyB;AAAA,IACzD,UAAU;AAAA,EACZ,CAAC;AAAA,EAED,eAAe,UAA6C;AAC1D,QAAI,CAAC,KAAK,kBAAkB;AAC1B,aAAO;AAAA,IACT;AACA,WAAO,KAAK,iBAAiB,eAAe,QAAQ;AAAA,EACtD;AACF;AAKO,MAAM,cAAc,MAAgC;AACzD,QAAM,mBAAmB,OAAO,yBAAyB,EAAE,UAAU,KAAK,CAAC;AAE3E,MAAI,CAAC,kBAAkB;AACrB,WAAO;AAAA,MACL,gBAAgB;AAAA,IAClB;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}