angular-intlayer 5.5.9 → 5.5.11

package/dist/cjs/editor/createSharedComposable.cjs

@@ -0,0 +1,68 @@
+"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 createSharedComposable_exports = {};
+__export(createSharedComposable_exports, {
+  createSharedComposable: () => createSharedComposable,
+  tryOnScopeDispose: () => tryOnScopeDispose
+});
+module.exports = __toCommonJS(createSharedComposable_exports);
+var import_core = require("@angular/core");
+function tryOnScopeDispose(fn) {
+  try {
+    const destroyRef = (0, import_core.inject)(import_core.DestroyRef, { optional: true });
+    if (destroyRef) {
+      destroyRef.onDestroy(fn);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+const createSharedComposable = (composable) => {
+  let subscribers = 0;
+  let state;
+  let cleanupFn;
+  const dispose = () => {
+    subscribers -= 1;
+    if (cleanupFn && subscribers <= 0) {
+      cleanupFn();
+      state = void 0;
+      cleanupFn = void 0;
+    }
+  };
+  return (...args) => {
+    subscribers += 1;
+    if (!state) {
+      state = composable(...args);
+      if (tryOnScopeDispose(dispose)) {
+        cleanupFn = dispose;
+      }
+    } else {
+      tryOnScopeDispose(dispose);
+    }
+    return state;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createSharedComposable,
+  tryOnScopeDispose
+});
+//# sourceMappingURL=createSharedComposable.cjs.map

package/dist/cjs/editor/createSharedComposable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/createSharedComposable.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core';\n\ntype AnyFn = (...args: any[]) => any;\n\nexport type SharedComposableReturn<T extends AnyFn = AnyFn> = T;\n\n/**\n * Angular replacement for Vue's tryOnScopeDispose\n * Uses Angular's DestroyRef to handle cleanup when the injection context is destroyed\n */\nexport function tryOnScopeDispose(fn: () => void) {\n  try {\n    const destroyRef = inject(DestroyRef, { optional: true });\n    if (destroyRef) {\n      destroyRef.onDestroy(fn);\n      return true;\n    }\n    return false;\n  } catch {\n    // If called outside injection context, return false\n    return false;\n  }\n}\n\n/**\n * Angular equivalent of Vue's createSharedComposable\n * Creates a singleton pattern for services/composables\n */\nexport const createSharedComposable = <Fn extends AnyFn>(\n  composable: Fn\n): SharedComposableReturn<Fn> => {\n  let subscribers = 0;\n  let state: ReturnType<Fn> | undefined;\n  let cleanupFn: (() => void) | undefined;\n\n  const dispose = () => {\n    subscribers -= 1;\n    if (cleanupFn && subscribers <= 0) {\n      cleanupFn();\n      state = undefined;\n      cleanupFn = undefined;\n    }\n  };\n\n  return <Fn>((...args) => {\n    subscribers += 1;\n    if (!state) {\n      state = composable(...args);\n      // Set up cleanup when the first subscriber is destroyed\n      if (tryOnScopeDispose(dispose)) {\n        cleanupFn = dispose;\n      }\n    } else {\n      // For additional subscribers, just set up their individual cleanup\n      tryOnScopeDispose(dispose);\n    }\n    return state;\n  });\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAmC;AAU5B,SAAS,kBAAkB,IAAgB;AAChD,MAAI;AACF,UAAM,iBAAa,oBAAO,wBAAY,EAAE,UAAU,KAAK,CAAC;AACxD,QAAI,YAAY;AACd,iBAAW,UAAU,EAAE;AACvB,aAAO;AAAA,IACT;AACA,WAAO;AAAA,EACT,QAAQ;AAEN,WAAO;AAAA,EACT;AACF;AAMO,MAAM,yBAAyB,CACpC,eAC+B;AAC/B,MAAI,cAAc;AAClB,MAAI;AACJ,MAAI;AAEJ,QAAM,UAAU,MAAM;AACpB,mBAAe;AACf,QAAI,aAAa,eAAe,GAAG;AACjC,gBAAU;AACV,cAAQ;AACR,kBAAY;AAAA,IACd;AAAA,EACF;AAEA,SAAY,IAAI,SAAS;AACvB,mBAAe;AACf,QAAI,CAAC,OAAO;AACV,cAAQ,WAAW,GAAG,IAAI;AAE1B,UAAI,kBAAkB,OAAO,GAAG;AAC9B,oBAAY;AAAA,MACd;AAAA,IACF,OAAO;AAEL,wBAAkB,OAAO;AAAA,IAC3B;AACA,WAAO;AAAA,EACT;AACF;","names":[]}

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"]}