angular-intlayer 5.5.8 → 5.5.10

package/dist/cjs/editor/dictionariesRecord.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dictionariesRecord_exports = {};
+__export(dictionariesRecord_exports, {
+  createDictionaryRecordClient: () => createDictionaryRecordClient,
+  installDictionariesRecord: () => installDictionariesRecord,
+  useDictionariesRecord: () => useDictionariesRecord
+});
+module.exports = __toCommonJS(dictionariesRecord_exports);
+var import_core = require("@angular/core");
+var import_dictionaries_entry = __toESM(require("@intlayer/dictionaries-entry"));
+var import_editor = require("@intlayer/editor");
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+let instance = null;
+const createDictionaryRecordClient = () => {
+  if (instance) return instance;
+  const localeDictionariesSignal = (0, import_core.signal)(import_dictionaries_entry.default);
+  instance = {
+    localeDictionaries: localeDictionariesSignal.asReadonly(),
+    setLocaleDictionaries: (newValue) => {
+      localeDictionariesSignal.set(newValue ?? {});
+    },
+    setLocaleDictionary(dictionary) {
+      const current = localeDictionariesSignal();
+      localeDictionariesSignal.set({
+        ...current,
+        [dictionary.key]: dictionary
+      });
+    }
+  };
+  return instance;
+};
+const installDictionariesRecord = (injector) => {
+  const client = createDictionaryRecordClient();
+};
+const useDictionariesRecord = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const client = createDictionaryRecordClient();
+  if (!client) {
+    throw new Error("DictionariesRecord state not found");
+  }
+  const [_dictionariesRecord, setDictionariesRecord] = (0, import_useCrossFrameState.useCrossFrameState)(
+    import_editor.MessageKey.INTLAYER_LOCALE_DICTIONARIES_CHANGED,
+    void 0
+  );
+  (0, import_core.effect)(() => {
+    const newValue = client.localeDictionaries();
+    setDictionariesRecord(newValue);
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDictionaryRecordClient,
+  installDictionariesRecord,
+  useDictionariesRecord
+});
+//# sourceMappingURL=dictionariesRecord.cjs.map

package/dist/cjs/editor/dictionariesRecord.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/dictionariesRecord.ts"],"sourcesContent":["import { effect, Injector, signal, Signal } from '@angular/core';\nimport type { Dictionary } from '@intlayer/core';\nimport dictionaries from '@intlayer/dictionaries-entry';\nimport { MessageKey } from '@intlayer/editor';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameState } from './useCrossFrameState';\n\n/**\n * Singleton instance\n */\nlet instance: DictionariesRecordClient | null = null;\n\nexport type DictionaryContent = Record<Dictionary['key'], Dictionary>;\n\ntype DictionariesRecordClient = {\n  localeDictionaries: Signal<DictionaryContent>;\n  setLocaleDictionaries: (newValue: DictionaryContent) => void;\n  setLocaleDictionary: (d: Dictionary) => void;\n};\n\nexport const createDictionaryRecordClient = () => {\n  if (instance) return instance;\n\n  const localeDictionariesSignal = signal<DictionaryContent>(dictionaries);\n\n  instance = {\n    localeDictionaries: localeDictionariesSignal.asReadonly(),\n\n    setLocaleDictionaries: (newValue) => {\n      localeDictionariesSignal.set(newValue ?? {});\n    },\n\n    setLocaleDictionary(dictionary) {\n      const current = localeDictionariesSignal();\n      localeDictionariesSignal.set({\n        ...current,\n        [dictionary.key]: dictionary,\n      });\n    },\n  };\n\n  return instance;\n};\n\n/**\n * Helper to install the provider into the injector\n */\nexport const installDictionariesRecord = (injector: Injector) => {\n  const client = createDictionaryRecordClient();\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 createDictionaryRecordClient\n};\n\nexport const useDictionariesRecord = createSharedComposable(() => {\n  const client = createDictionaryRecordClient();\n\n  if (!client) {\n    throw new Error('DictionariesRecord state not found');\n  }\n\n  const [_dictionariesRecord, setDictionariesRecord] =\n    useCrossFrameState<DictionaryContent>(\n      MessageKey.INTLAYER_LOCALE_DICTIONARIES_CHANGED,\n      undefined\n    );\n\n  // Use Angular effects instead of Vue watchers\n  effect(() => {\n    const newValue = client.localeDictionaries();\n    setDictionariesRecord(newValue); // its undefined but shouldnt\n  });\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiD;AAEjD,gCAAyB;AACzB,oBAA2B;AAC3B,oCAAuC;AACvC,gCAAmC;AAKnC,IAAI,WAA4C;AAUzC,MAAM,+BAA+B,MAAM;AAChD,MAAI,SAAU,QAAO;AAErB,QAAM,+BAA2B,oBAA0B,0BAAAA,OAAY;AAEvE,aAAW;AAAA,IACT,oBAAoB,yBAAyB,WAAW;AAAA,IAExD,uBAAuB,CAAC,aAAa;AACnC,+BAAyB,IAAI,YAAY,CAAC,CAAC;AAAA,IAC7C;AAAA,IAEA,oBAAoB,YAAY;AAC9B,YAAM,UAAU,yBAAyB;AACzC,+BAAyB,IAAI;AAAA,QAC3B,GAAG;AAAA,QACH,CAAC,WAAW,GAAG,GAAG;AAAA,MACpB,CAAC;AAAA,IACH;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,4BAA4B,CAAC,aAAuB;AAC/D,QAAM,SAAS,6BAA6B;AAI9C;AAEO,MAAM,4BAAwB,sDAAuB,MAAM;AAChE,QAAM,SAAS,6BAA6B;AAE5C,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AAEA,QAAM,CAAC,qBAAqB,qBAAqB,QAC/C;AAAA,IACE,yBAAW;AAAA,IACX;AAAA,EACF;AAGF,0BAAO,MAAM;AACX,UAAM,WAAW,OAAO,mBAAmB;AAC3C,0BAAsB,QAAQ;AAAA,EAChC,CAAC;AACH,CAAC;","names":["dictionaries"]}

package/dist/cjs/editor/editedContent.cjs

@@ -0,0 +1,77 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editedContent_exports = {};
+__export(editedContent_exports, {
+  createEditedContentClient: () => createEditedContentClient,
+  installEditedContent: () => installEditedContent,
+  useEditedContent: () => useEditedContent
+});
+module.exports = __toCommonJS(editedContent_exports);
+var import_core = require("@angular/core");
+var import_core2 = require("@intlayer/core");
+var import_editor = require("@intlayer/editor");
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+let instance = null;
+const INTLAYER_EDITED_CONTENT_SYMBOL = Symbol("EditedContent");
+const createEditedContentClient = () => {
+  if (instance) return instance;
+  const editedContentSignal = (0, import_core.signal)({});
+  instance = {
+    editedContent: editedContentSignal.asReadonly(),
+    getEditedContentValue: (dictionaryKey, keyPath) => {
+      const content = editedContentSignal()?.[dictionaryKey]?.content;
+      if (!content) return void 0;
+      return (0, import_core2.getContentNodeByKeyPath)(content, keyPath);
+    },
+    setEditedContent: (editedContent) => {
+      editedContentSignal.set(editedContent);
+    }
+  };
+  return instance;
+};
+const installEditedContent = (injector) => {
+  const client = createEditedContentClient();
+};
+const useEditedContent = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const client = createEditedContentClient();
+  if (!client) {
+    throw new Error("EditedContent state not found");
+  }
+  const [edited, setEdited] = (0, import_useCrossFrameState.useCrossFrameState)(
+    import_editor.MessageKey.INTLAYER_EDITED_CONTENT_CHANGED,
+    {}
+  );
+  (0, import_core.effect)(() => {
+    const newValue = edited();
+    client.setEditedContent(newValue ?? {});
+  });
+  (0, import_core.effect)(() => {
+    const newValue = client.editedContent();
+    setEdited(newValue);
+  });
+  return client;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEditedContentClient,
+  installEditedContent,
+  useEditedContent
+});
+//# sourceMappingURL=editedContent.cjs.map

package/dist/cjs/editor/editedContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/editedContent.ts"],"sourcesContent":["import { effect, Injector, signal, Signal } from '@angular/core';\nimport type { ContentNode, Dictionary, KeyPath } from '@intlayer/core';\nimport { getContentNodeByKeyPath } from '@intlayer/core';\nimport { MessageKey } from '@intlayer/editor';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport type EditedContent = Record<Dictionary['key'], Dictionary>;\n\ntype EditedContentClient = {\n  editedContent: Signal<EditedContent>;\n  setEditedContent: (editedContent: EditedContent) => void;\n  getEditedContentValue: (\n    dictionaryKey: Dictionary['key'],\n    keyPath: KeyPath[]\n  ) => ContentNode | undefined;\n};\n\n/**\n * Singleton instance\n */\nlet instance: EditedContentClient | null = null;\n\nconst INTLAYER_EDITED_CONTENT_SYMBOL = Symbol('EditedContent');\n\n/**\n * Creates an edited content client\n */\nexport const createEditedContentClient = () => {\n  if (instance) return instance;\n\n  const editedContentSignal = signal<EditedContent>({});\n\n  instance = {\n    editedContent: editedContentSignal.asReadonly(),\n    getEditedContentValue: (\n      dictionaryKey: Dictionary['key'],\n      keyPath: KeyPath[]\n    ): ContentNode | undefined => {\n      const content = editedContentSignal()?.[dictionaryKey]?.content;\n      if (!content) return undefined;\n\n      return getContentNodeByKeyPath(content, keyPath);\n    },\n    setEditedContent: (editedContent: EditedContent) => {\n      editedContentSignal.set(editedContent);\n    },\n  };\n\n  return instance;\n};\n\n/**\n * Helper to install the edited content into the injector\n */\nexport const installEditedContent = (injector: Injector) => {\n  const client = createEditedContentClient();\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 createEditedContentClient\n};\n\nexport const useEditedContent = createSharedComposable(() => {\n  const client = createEditedContentClient();\n\n  if (!client) {\n    throw new Error('EditedContent state not found');\n  }\n\n  const [edited, setEdited] = useCrossFrameState<EditedContent>(\n    MessageKey.INTLAYER_EDITED_CONTENT_CHANGED,\n    {}\n  );\n\n  // Use Angular effects instead of Vue watchers\n  effect(() => {\n    const newValue = edited();\n    client.setEditedContent(newValue ?? {});\n  });\n\n  effect(() => {\n    const newValue = client.editedContent();\n    setEdited(newValue);\n  });\n\n  return client;\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiD;AAEjD,IAAAA,eAAwC;AACxC,oBAA2B;AAC3B,oCAAuC;AACvC,gCAAmC;AAgBnC,IAAI,WAAuC;AAE3C,MAAM,iCAAiC,OAAO,eAAe;AAKtD,MAAM,4BAA4B,MAAM;AAC7C,MAAI,SAAU,QAAO;AAErB,QAAM,0BAAsB,oBAAsB,CAAC,CAAC;AAEpD,aAAW;AAAA,IACT,eAAe,oBAAoB,WAAW;AAAA,IAC9C,uBAAuB,CACrB,eACA,YAC4B;AAC5B,YAAM,UAAU,oBAAoB,IAAI,aAAa,GAAG;AACxD,UAAI,CAAC,QAAS,QAAO;AAErB,iBAAO,sCAAwB,SAAS,OAAO;AAAA,IACjD;AAAA,IACA,kBAAkB,CAAC,kBAAiC;AAClD,0BAAoB,IAAI,aAAa;AAAA,IACvC;AAAA,EACF;AAEA,SAAO;AACT;AAKO,MAAM,uBAAuB,CAAC,aAAuB;AAC1D,QAAM,SAAS,0BAA0B;AAI3C;AAEO,MAAM,uBAAmB,sDAAuB,MAAM;AAC3D,QAAM,SAAS,0BAA0B;AAEzC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AAEA,QAAM,CAAC,QAAQ,SAAS,QAAI;AAAA,IAC1B,yBAAW;AAAA,IACX,CAAC;AAAA,EACH;AAGA,0BAAO,MAAM;AACX,UAAM,WAAW,OAAO;AACxB,WAAO,iBAAiB,YAAY,CAAC,CAAC;AAAA,EACxC,CAAC;AAED,0BAAO,MAAM;AACX,UAAM,WAAW,OAAO,cAAc;AACtC,cAAU,QAAQ;AAAA,EACpB,CAAC;AAED,SAAO;AACT,CAAC;","names":["import_core"]}

package/dist/cjs/editor/editorEnabled.cjs

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editorEnabled_exports = {};
+__export(editorEnabled_exports, {
+  createEditorEnabledClient: () => createEditorEnabledClient,
+  installEditorEnabled: () => installEditorEnabled,
+  useEditorEnabled: () => useEditorEnabled
+});
+module.exports = __toCommonJS(editorEnabled_exports);
+var import_core = require("@angular/core");
+var import_editor = require("@intlayer/editor");
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
+let instance = null;
+const INTLAYER_EDITOR_ENABLED_SYMBOL = Symbol("EditorEnabled");
+const createEditorEnabledClient = () => {
+  if (instance) return instance;
+  const wrapperEnabledSignal = (0, import_core.signal)(false);
+  const isInIframeSignal = (0, import_core.signal)(false);
+  const enabledSignal = (0, import_core.computed)(
+    () => wrapperEnabledSignal() && isInIframeSignal()
+  );
+  instance = {
+    wrapperEnabled: wrapperEnabledSignal.asReadonly(),
+    isInIframe: isInIframeSignal.asReadonly(),
+    enabled: enabledSignal
+  };
+  return instance;
+};
+const installEditorEnabled = (injector) => {
+  const client = createEditorEnabledClient();
+};
+const useEditorEnabled = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const client = createEditorEnabledClient();
+  if (!client) {
+    throw new Error("EditorEnabled state not found");
+  }
+  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    `${import_editor.MessageKey.INTLAYER_EDITOR_ENABLED}/post`,
+    (data) => {
+      client.wrapperEnabled.set(data);
+    }
+  );
+  (0, import_core.effect)(
+    () => {
+      if (typeof window !== "undefined") {
+        client.isInIframe.set(window.self !== window.top);
+      }
+    },
+    { allowSignalWrites: true }
+  );
+  return client;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEditorEnabledClient,
+  installEditorEnabled,
+  useEditorEnabled
+});
+//# sourceMappingURL=editorEnabled.cjs.map

package/dist/cjs/editor/editorEnabled.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/editorEnabled.ts"],"sourcesContent":["import { computed, effect, Injector, signal, Signal } from '@angular/core';\nimport { MessageKey } from '@intlayer/editor';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameMessageListener } from './useCrossFrameMessageListener';\n\n/* ------------------------------------------------------------------ */\n/*  public type – identical to the React version                       */\n/* ------------------------------------------------------------------ */\nexport type EditorEnabledStateProps = {\n  wrapperEnabled: Signal<boolean>;\n  isInIframe: Signal<boolean>;\n  enabled: Signal<boolean>;\n};\n\n/**\n * Singleton instance\n */\nlet instance: EditorEnabledStateProps | null = null;\n\nconst INTLAYER_EDITOR_ENABLED_SYMBOL = Symbol('EditorEnabled');\n\n/**\n * Creates an editor wrapperEnabled client\n */\nexport const createEditorEnabledClient = () => {\n  if (instance) return instance;\n\n  const wrapperEnabledSignal = signal(false);\n  const isInIframeSignal = signal(false);\n  const enabledSignal = computed(\n    () => wrapperEnabledSignal() && isInIframeSignal()\n  );\n\n  instance = {\n    wrapperEnabled: wrapperEnabledSignal.asReadonly(),\n    isInIframe: isInIframeSignal.asReadonly(),\n    enabled: enabledSignal,\n  };\n\n  return instance;\n};\n\n/**\n * Helper to install the editor wrapperEnabled state into the injector\n */\nexport const installEditorEnabled = (injector: Injector) => {\n  const client = createEditorEnabledClient();\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 createEditorEnabledClient\n};\n\nexport const useEditorEnabled = createSharedComposable(() => {\n  const client = createEditorEnabledClient();\n\n  if (!client) {\n    throw new Error('EditorEnabled state not found');\n  }\n\n  // Listen for the iframe parent if the editor send a message `INTLAYER_EDITOR_ENABLED`\n  useCrossFrameMessageListener<boolean>(\n    `${MessageKey.INTLAYER_EDITOR_ENABLED}/post`,\n    (data) => {\n      (client.wrapperEnabled as any).set(data);\n    }\n  );\n\n  // Use effect to set up the iframe check immediately\n  effect(\n    () => {\n      if (typeof window !== 'undefined') {\n        (client.isInIframe as any).set(window.self !== window.top);\n      }\n    },\n    { allowSignalWrites: true }\n  );\n\n  return client;\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA2D;AAC3D,oBAA2B;AAC3B,oCAAuC;AACvC,0CAA6C;AAc7C,IAAI,WAA2C;AAE/C,MAAM,iCAAiC,OAAO,eAAe;AAKtD,MAAM,4BAA4B,MAAM;AAC7C,MAAI,SAAU,QAAO;AAErB,QAAM,2BAAuB,oBAAO,KAAK;AACzC,QAAM,uBAAmB,oBAAO,KAAK;AACrC,QAAM,oBAAgB;AAAA,IACpB,MAAM,qBAAqB,KAAK,iBAAiB;AAAA,EACnD;AAEA,aAAW;AAAA,IACT,gBAAgB,qBAAqB,WAAW;AAAA,IAChD,YAAY,iBAAiB,WAAW;AAAA,IACxC,SAAS;AAAA,EACX;AAEA,SAAO;AACT;AAKO,MAAM,uBAAuB,CAAC,aAAuB;AAC1D,QAAM,SAAS,0BAA0B;AAI3C;AAEO,MAAM,uBAAmB,sDAAuB,MAAM;AAC3D,QAAM,SAAS,0BAA0B;AAEzC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AAGA;AAAA,IACE,GAAG,yBAAW,uBAAuB;AAAA,IACrC,CAAC,SAAS;AACR,MAAC,OAAO,eAAuB,IAAI,IAAI;AAAA,IACzC;AAAA,EACF;AAGA;AAAA,IACE,MAAM;AACJ,UAAI,OAAO,WAAW,aAAa;AACjC,QAAC,OAAO,WAAmB,IAAI,OAAO,SAAS,OAAO,GAAG;AAAA,MAC3D;AAAA,IACF;AAAA,IACA,EAAE,mBAAmB,KAAK;AAAA,EAC5B;AAEA,SAAO;AACT,CAAC;","names":[]}

package/dist/cjs/editor/editorLocale.cjs

@@ -0,0 +1,47 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editorLocale_exports = {};
+__export(editorLocale_exports, {
+  useEditorLocale: () => useEditorLocale
+});
+module.exports = __toCommonJS(editorLocale_exports);
+var import_core = require("@angular/core");
+var import_editor = require("@intlayer/editor");
+var import_client = require('../client/index.cjs');
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+const useEditorLocale = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const client = (0, import_core.inject)(import_client.INTLAYER_TOKEN);
+  if (!client) {
+    throw new Error("IntlayerEditor state not found");
+  }
+  const [_data, setData] = (0, import_useCrossFrameState.useCrossFrameState)(
+    import_editor.MessageKey.INTLAYER_CURRENT_LOCALE
+  );
+  (0, import_core.effect)(() => {
+    const newValue = client.locale();
+    setData(newValue);
+  });
+  return client;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEditorLocale
+});
+//# sourceMappingURL=editorLocale.cjs.map

package/dist/cjs/editor/editorLocale.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/editorLocale.ts"],"sourcesContent":["import { effect, inject } from '@angular/core';\nimport type { Locales } from '@intlayer/config/client';\nimport { MessageKey } from '@intlayer/editor';\nimport { INTLAYER_TOKEN, IntlayerProvider } from '../client';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport const useEditorLocale = createSharedComposable(() => {\n  const client = inject<IntlayerProvider>(INTLAYER_TOKEN);\n\n  if (!client) {\n    throw new Error('IntlayerEditor state not found');\n  }\n\n  const [_data, setData] = useCrossFrameState<Locales>(\n    MessageKey.INTLAYER_CURRENT_LOCALE\n  );\n\n  // Use Angular effects instead of Vue watchers\n  effect(() => {\n    const newValue = client.locale();\n    setData(newValue);\n  });\n\n  return client;\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAA+B;AAE/B,oBAA2B;AAC3B,oBAAiD;AACjD,oCAAuC;AACvC,gCAAmC;AAE5B,MAAM,sBAAkB,sDAAuB,MAAM;AAC1D,QAAM,aAAS,oBAAyB,4BAAc;AAEtD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AAEA,QAAM,CAAC,OAAO,OAAO,QAAI;AAAA,IACvB,yBAAW;AAAA,EACb;AAGA,0BAAO,MAAM;AACX,UAAM,WAAW,OAAO,OAAO;AAC/B,YAAQ,QAAQ;AAAA,EAClB,CAAC;AAED,SAAO;AACT,CAAC;","names":[]}

package/dist/cjs/editor/focusDictionary.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var focusDictionary_exports = {};
+__export(focusDictionary_exports, {
+  createFocusDictionaryClient: () => createFocusDictionaryClient,
+  installFocusDictionary: () => installFocusDictionary,
+  useFocusDictionary: () => useFocusDictionary
+});
+module.exports = __toCommonJS(focusDictionary_exports);
+var import_core = require("@angular/core");
+var import_editor = require("@intlayer/editor");
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+let instance = null;
+const createFocusDictionaryClient = () => {
+  if (instance) return instance;
+  const focusedContentSignal = (0, import_core.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 = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const client = createFocusDictionaryClient();
+  const [focusedContent, setFocusedContent] = (0, import_useCrossFrameState.useCrossFrameState)(
+    import_editor.MessageKey.INTLAYER_FOCUSED_CONTENT_CHANGED
+  );
+  if (!client) {
+    throw new Error("FocusDictionary state not found");
+  }
+  (0, import_core.effect)(() => {
+    const newValue = client.focusedContent();
+    if (JSON.stringify(newValue) !== JSON.stringify(focusedContent())) {
+      setFocusedContent(newValue);
+    }
+  });
+  (0, import_core.effect)(() => {
+    const newValue = focusedContent();
+    if (JSON.stringify(newValue) !== JSON.stringify(client.focusedContent())) {
+      client.setFocusedContent(newValue ?? null);
+    }
+  });
+  return client;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFocusDictionaryClient,
+  installFocusDictionary,
+  useFocusDictionary
+});
+//# sourceMappingURL=focusDictionary.cjs.map

package/dist/cjs/editor/focusDictionary.cjs.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiD;AAEjD,oBAA2B;AAC3B,oCAAuC;AACvC,gCAAmC;AAiBnC,IAAI,WAAyC;AAKtC,MAAM,8BAA8B,MAAM;AAC/C,MAAI,SAAU,QAAO;AAErB,QAAM,2BAAuB,oBAA2B,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,yBAAqB,sDAAuB,MAAM;AAC7D,QAAM,SAAS,4BAA4B;AAC3C,QAAM,CAAC,gBAAgB,iBAAiB,QACtC;AAAA,IACE,yBAAW;AAAA,EACb;AAEF,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AAIA,0BAAO,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,0BAAO,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/cjs/editor/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var editor_exports = {};
+__export(editor_exports, {
+  ContentSelectorWrapperComponent: () => import_ContentSelectorWrapper.ContentSelectorWrapperComponent,
+  EditedContentRendererComponent: () => import_EditedContentRenderer.EditedContentRendererComponent,
+  EditorSelectorRendererComponent: () => import_EditorSelectorRenderer.EditorSelectorRendererComponent
+});
+module.exports = __toCommonJS(editor_exports);
+var import_ContentSelectorWrapper = require('./ContentSelectorWrapper.component.cjs');
+var import_EditedContentRenderer = require('./EditedContentRenderer.component.cjs');
+var import_EditorSelectorRenderer = require('./EditorSelectorRenderer.component.cjs');
+__reExport(editor_exports, require('./installIntlayerEditor.cjs'), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentSelectorWrapperComponent,
+  EditedContentRendererComponent,
+  EditorSelectorRendererComponent,
+  ...require('./installIntlayerEditor.cjs')
+});
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/editor/index.cjs.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;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oCAAgD;AAChD,mCAA+C;AAC/C,oCAAgD;AAChD,2BAAc,oCAHd;","names":[]}

package/dist/cjs/editor/installIntlayerEditor.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var installIntlayerEditor_exports = {};
+__export(installIntlayerEditor_exports, {
+  installIntlayerEditor: () => installIntlayerEditor
+});
+module.exports = __toCommonJS(installIntlayerEditor_exports);
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_changedContent = require('./changedContent.cjs');
+var import_communicator = require('./communicator.cjs');
+var import_dictionariesRecord = require('./dictionariesRecord.cjs');
+var import_editedContent = require('./editedContent.cjs');
+var import_editorEnabled = require('./editorEnabled.cjs');
+var import_focusDictionary = require('./focusDictionary.cjs');
+const { editor } = import_built.default;
+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) => {
+  (0, import_communicator.installCommunicator)(injector, {
+    postMessage,
+    allowedOrigins: [applicationURL, editorURL, cmsURL]
+  });
+  (0, import_editorEnabled.installEditorEnabled)(injector);
+  (0, import_changedContent.installChangedContent)(injector);
+  (0, import_dictionariesRecord.installDictionariesRecord)(injector);
+  (0, import_editedContent.installEditedContent)(injector);
+  (0, import_focusDictionary.installFocusDictionary)(injector);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installIntlayerEditor
+});
+//# sourceMappingURL=installIntlayerEditor.cjs.map

package/dist/cjs/editor/installIntlayerEditor.cjs.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA0B;AAC1B,4BAAsC;AACtC,0BAAoC;AACpC,gCAA0C;AAC1C,2BAAqC;AACrC,2BAAqC;AACrC,6BAAuC;AAEvC,MAAM,EAAE,OAAO,IAAI,aAAAA;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,+CAAoB,UAAU;AAAA,IAC5B;AAAA,IACA,gBAAgB,CAAC,gBAAgB,WAAW,MAAM;AAAA,EACpD,CAAC;AACD,iDAAqB,QAAQ;AAC7B,mDAAsB,QAAQ;AAC9B,2DAA0B,QAAQ;AAClC,iDAAqB,QAAQ;AAC7B,qDAAuB,QAAQ;AACjC;","names":["configuration"]}

package/dist/cjs/editor/useCrossFrameMessageListener.cjs

@@ -0,0 +1,83 @@
+"use strict";
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useCrossFrameMessageListener_exports = {};
+__export(useCrossFrameMessageListener_exports, {
+  useCrossFrameMessageListener: () => useCrossFrameMessageListener
+});
+module.exports = __toCommonJS(useCrossFrameMessageListener_exports);
+var import_core = require("@angular/core");
+var import_editor = require("@intlayer/editor");
+var import_communicator = require('./communicator.cjs');
+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) => (0, import_editor.compareUrls)(o, event.origin))) {
+      subscribers.get(type)?.forEach((cb) => cb(data));
+    }
+  });
+  windowListenerAttached = true;
+}
+const useCrossFrameMessageListener = (key, onEventTriggered) => {
+  const { allowedOrigins, postMessage, senderId } = (0, import_communicator.useCommunicator)();
+  ensureGlobalListener(allowedOrigins, senderId);
+  if (onEventTriggered) {
+    addSubscriber(key, onEventTriggered);
+    try {
+      const destroyRef = (0, import_core.inject)(import_core.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCrossFrameMessageListener
+});
+//# sourceMappingURL=useCrossFrameMessageListener.cjs.map

package/dist/cjs/editor/useCrossFrameMessageListener.cjs.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":";;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,kBAAmC;AACnC,oBAA6C;AAC7C,0BAAgC;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,UAAM,2BAAY,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,QAAI,qCAAgB;AAGlE,uBAAqB,gBAAgB,QAAQ;AAG7C,MAAI,kBAAkB;AACpB,kBAAc,KAAK,gBAAyB;AAG5C,QAAI;AACF,YAAM,iBAAa,oBAAO,wBAAY,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":[]}