angular-intlayer 5.5.9 → 5.5.10

package/dist/cjs/client/useLocaleCookie.cjs

@@ -0,0 +1,60 @@
+"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 useLocaleCookie_exports = {};
+__export(useLocaleCookie_exports, {
+  localeCookie: () => localeCookie,
+  setLocaleCookie: () => setLocaleCookie,
+  useLocaleCookie: () => useLocaleCookie
+});
+module.exports = __toCommonJS(useLocaleCookie_exports);
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_js_cookie = __toESM(require("js-cookie"));
+const { cookieName } = import_built.default.middleware;
+const cookieAttributes = {
+  path: "/",
+  expires: void 0,
+  domain: void 0,
+  secure: false,
+  sameSite: "strict"
+};
+const localeCookie = import_js_cookie.default.get(cookieName);
+const setLocaleCookie = (locale) => {
+  import_js_cookie.default.set(cookieName, locale, cookieAttributes);
+};
+const useLocaleCookie = () => ({
+  localeCookie,
+  setLocaleCookie
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  localeCookie,
+  setLocaleCookie,
+  useLocaleCookie
+});
+//# sourceMappingURL=useLocaleCookie.cjs.map

package/dist/cjs/client/useLocaleCookie.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useLocaleCookie.ts"],"sourcesContent":["import configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/config/client';\n\nimport Cookies from 'js-cookie';\n\nconst { cookieName } = configuration.middleware;\n\nconst cookieAttributes: Cookies.CookieAttributes = {\n  path: '/',\n  expires: undefined,\n  domain: undefined,\n  secure: false,\n  sameSite: 'strict',\n};\n\n/**\n * Get the locale cookie\n */\nexport const localeCookie = Cookies.get(cookieName) as unknown as\n  | LocalesValues\n  | undefined;\n\n/**\n * Set the locale cookie\n */\nexport const setLocaleCookie = (locale: LocalesValues) => {\n  Cookies.set(cookieName, locale, cookieAttributes);\n};\n\n/**\n * Hook that provides the locale cookie and a function to set it\n */\nexport const useLocaleCookie = () => ({\n  localeCookie,\n  setLocaleCookie,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA0B;AAG1B,uBAAoB;AAEpB,MAAM,EAAE,WAAW,IAAI,aAAAA,QAAc;AAErC,MAAM,mBAA6C;AAAA,EACjD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AACZ;AAKO,MAAM,eAAe,iBAAAC,QAAQ,IAAI,UAAU;AAO3C,MAAM,kBAAkB,CAAC,WAA0B;AACxD,mBAAAA,QAAQ,IAAI,YAAY,QAAQ,gBAAgB;AAClD;AAKO,MAAM,kBAAkB,OAAO;AAAA,EACpC;AAAA,EACA;AACF;","names":["configuration","Cookies"]}

package/dist/cjs/editor/ContentSelectorWrapper.component.cjs

@@ -0,0 +1,73 @@
+"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 ContentSelectorWrapper_component_exports = {};
+__export(ContentSelectorWrapper_component_exports, {
+  ContentSelectorWrapperComponent: () => ContentSelectorWrapperComponent
+});
+module.exports = __toCommonJS(ContentSelectorWrapper_component_exports);
+var import_common = require("@angular/common");
+var import_core = require("@angular/core");
+var import_core2 = require("@intlayer/core");
+var import_ContentSelector = require('../UI/ContentSelector.component.cjs');
+var import_editorEnabled = require('./editorEnabled.cjs');
+var import_focusDictionary = require('./focusDictionary.cjs');
+var import_useEditor = require('./useEditor.cjs');
+@((0, import_core.Component)({
+  selector: "app-content-selector-wrapper",
+  standalone: true,
+  imports: [import_common.CommonModule, import_ContentSelector.ContentSelectorComponent],
+  template: `
+    <app-content-selector
+      *ngIf="enabled()"
+      (press)="handleSelect()"
+      [isSelecting]="isSelected()"
+    >
+      <ng-content></ng-content>
+    </app-content-selector>
+    <ng-content *ngIf="!enabled()"></ng-content>
+  `
+}))
+class ContentSelectorWrapperComponent {
+  @((0, import_core.Input)()) dictionaryKey;
+  @((0, import_core.Input)()) keyPath;
+  // pull in the editor state & focus API
+  focusDictionary = (0, import_focusDictionary.useFocusDictionary)();
+  editorEnabled = (0, import_editorEnabled.useEditorEnabled)();
+  constructor() {
+    (0, import_useEditor.useEditor)();
+  }
+  // compute whether this node is the current focus
+  isSelected = (0, import_core.computed)(() => {
+    const focusedContent = this.focusDictionary.focusedContent();
+    return focusedContent?.dictionaryKey === this.dictionaryKey && (focusedContent.keyPath?.length ?? 0) > 0 && (0, import_core2.isSameKeyPath)(focusedContent.keyPath ?? [], this.keyPath);
+  });
+  enabled = (0, import_core.computed)(() => this.editorEnabled.enabled());
+  // when the selector is clicked, update focus
+  handleSelect() {
+    this.focusDictionary.setFocusedContent({
+      dictionaryKey: this.dictionaryKey,
+      keyPath: this.keyPath
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentSelectorWrapperComponent
+});
+//# sourceMappingURL=ContentSelectorWrapper.component.cjs.map

package/dist/cjs/editor/ContentSelectorWrapper.component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/ContentSelectorWrapper.component.ts"],"sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input, computed } from '@angular/core';\nimport { isSameKeyPath, type NodeProps } from '@intlayer/core';\nimport { ContentSelectorComponent } from '../UI/ContentSelector.component';\nimport { useEditorEnabled } from './editorEnabled';\nimport { useFocusDictionary } from './focusDictionary';\nimport { useEditor } from './useEditor';\n\n/**\n * Combine your NodeProps (which include dictionaryKey & keyPath)\n * with any other div-like attributes.\n */\nexport interface ContentSelectorWrapperProps extends NodeProps {\n  [key: string]: any;\n}\n\n@Component({\n  selector: 'app-content-selector-wrapper',\n  standalone: true,\n  imports: [CommonModule, ContentSelectorComponent],\n  template: `\n    <app-content-selector\n      *ngIf=\"enabled()\"\n      (press)=\"handleSelect()\"\n      [isSelecting]=\"isSelected()\"\n    >\n      <ng-content></ng-content>\n    </app-content-selector>\n    <ng-content *ngIf=\"!enabled()\"></ng-content>\n  `,\n})\nexport class ContentSelectorWrapperComponent {\n  @Input() dictionaryKey!: string;\n  @Input() keyPath!: any[];\n\n  // pull in the editor state & focus API\n  private focusDictionary = useFocusDictionary();\n  private editorEnabled = useEditorEnabled();\n\n  constructor() {\n    useEditor();\n  }\n\n  // compute whether this node is the current focus\n  isSelected = computed(() => {\n    const focusedContent = this.focusDictionary.focusedContent();\n    return (\n      focusedContent?.dictionaryKey === this.dictionaryKey &&\n      (focusedContent.keyPath?.length ?? 0) > 0 &&\n      isSameKeyPath(focusedContent.keyPath ?? [], this.keyPath)\n    );\n  });\n\n  enabled = computed(() => this.editorEnabled.enabled());\n\n  // when the selector is clicked, update focus\n  handleSelect() {\n    this.focusDictionary.setFocusedContent({\n      dictionaryKey: this.dictionaryKey,\n      keyPath: this.keyPath,\n    });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6B;AAC7B,kBAA2C;AAC3C,IAAAA,eAA8C;AAC9C,6BAAyC;AACzC,2BAAiC;AACjC,6BAAmC;AACnC,uBAA0B;AAU1B,MAAC,uBAAU;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,SAAS,CAAC,4BAAc,+CAAwB;AAAA,EAChD,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUZ,CAAC;AACM,MAAM,gCAAgC;AAC3C,QAAC,mBAAM,GAAE;AACT,QAAC,mBAAM,GAAE;AAAA;AAAA,EAGD,sBAAkB,2CAAmB;AAAA,EACrC,oBAAgB,uCAAiB;AAAA,EAEzC,cAAc;AACZ,oCAAU;AAAA,EACZ;AAAA;AAAA,EAGA,iBAAa,sBAAS,MAAM;AAC1B,UAAM,iBAAiB,KAAK,gBAAgB,eAAe;AAC3D,WACE,gBAAgB,kBAAkB,KAAK,kBACtC,eAAe,SAAS,UAAU,KAAK,SACxC,4BAAc,eAAe,WAAW,CAAC,GAAG,KAAK,OAAO;AAAA,EAE5D,CAAC;AAAA,EAED,cAAU,sBAAS,MAAM,KAAK,cAAc,QAAQ,CAAC;AAAA;AAAA,EAGrD,eAAe;AACb,SAAK,gBAAgB,kBAAkB;AAAA,MACrC,eAAe,KAAK;AAAA,MACpB,SAAS,KAAK;AAAA,IAChB,CAAC;AAAA,EACH;AACF;","names":["import_core"]}

package/dist/cjs/editor/EditedContentRenderer.component.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 EditedContentRenderer_component_exports = {};
+__export(EditedContentRenderer_component_exports, {
+  EditedContentRendererComponent: () => EditedContentRendererComponent
+});
+module.exports = __toCommonJS(EditedContentRenderer_component_exports);
+var import_common = require("@angular/common");
+var import_core = require("@angular/core");
+var import_core2 = require("@intlayer/core");
+var import_useEditedContentRenderer = require('./useEditedContentRenderer.cjs');
+@((0, import_core.Component)({
+  selector: "app-edited-content-renderer",
+  standalone: true,
+  imports: [import_common.CommonModule],
+  template: ` <span [innerHTML]="renderedContent()"></span> `
+}))
+class EditedContentRendererComponent {
+  @((0, import_core.Input)()) dictionaryKey;
+  @((0, import_core.Input)()) keyPath;
+  @((0, import_core.Input)()) locale;
+  fallback = (0, import_core.signal)("");
+  rawContent = (0, import_core.computed)(() => {
+    return (0, import_useEditedContentRenderer.useEditedContentRenderer)(
+      this.dictionaryKey,
+      this.keyPath,
+      this.fallback
+    );
+  });
+  /**
+   * Object → getContent → string, same as the React version.
+   */
+  renderedContent = (0, import_core.computed)(() => {
+    const rawContentValue = this.rawContent();
+    if (typeof rawContentValue === "object" && rawContentValue !== null) {
+      const transformed = (0, import_core2.getContent)(
+        rawContentValue,
+        {
+          dictionaryKey: this.dictionaryKey,
+          keyPath: this.keyPath
+        },
+        this.locale
+      );
+      if (typeof transformed !== "string") {
+        console.error(
+          `Incorrect edited content format. Content type: ${typeof transformed}. Expected string. Value ${JSON.stringify(
+            transformed
+          )}`
+        );
+        return this.fallback();
+      }
+      return transformed;
+    }
+    return rawContentValue();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EditedContentRendererComponent
+});
+//# sourceMappingURL=EditedContentRenderer.component.cjs.map

package/dist/cjs/editor/EditedContentRenderer.component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/EditedContentRenderer.component.ts"],"sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input, computed, signal } from '@angular/core';\nimport type { Locales } from '@intlayer/config/client';\nimport { ContentNode, getContent, type KeyPath } from '@intlayer/core';\nimport { useEditedContentRenderer } from './useEditedContentRenderer';\n\nexport interface EditedContentRendererProps {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: Locales;\n}\n\n@Component({\n  selector: 'app-edited-content-renderer',\n  standalone: true,\n  imports: [CommonModule],\n  template: ` <span [innerHTML]=\"renderedContent()\"></span> `,\n})\nexport class EditedContentRendererComponent {\n  @Input() dictionaryKey!: string;\n  @Input() keyPath!: KeyPath[];\n  @Input() locale?: Locales;\n\n  private fallback = signal('');\n\n  private rawContent = computed(() => {\n    return useEditedContentRenderer(\n      this.dictionaryKey,\n      this.keyPath,\n      this.fallback\n    );\n  });\n\n  /**\n   * Object → getContent → string, same as the React version.\n   */\n  renderedContent = computed(() => {\n    const rawContentValue = this.rawContent();\n\n    if (typeof rawContentValue === 'object' && rawContentValue !== null) {\n      const transformed = getContent(\n        rawContentValue as ContentNode,\n        {\n          dictionaryKey: this.dictionaryKey,\n          keyPath: this.keyPath,\n        },\n        this.locale\n      );\n\n      if (typeof transformed !== 'string') {\n        console.error(\n          `Incorrect edited content format. Content type: ${typeof transformed}. Expected string. Value ${JSON.stringify(\n            transformed\n          )}`\n        );\n        return this.fallback();\n      }\n      return transformed;\n    }\n\n    return rawContentValue() as string;\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6B;AAC7B,kBAAmD;AAEnD,IAAAA,eAAsD;AACtD,sCAAyC;AAQzC,MAAC,uBAAU;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,SAAS,CAAC,0BAAY;AAAA,EACtB,UAAU;AACZ,CAAC;AACM,MAAM,+BAA+B;AAC1C,QAAC,mBAAM,GAAE;AACT,QAAC,mBAAM,GAAE;AACT,QAAC,mBAAM,GAAE;AAAA,EAED,eAAW,oBAAO,EAAE;AAAA,EAEpB,iBAAa,sBAAS,MAAM;AAClC,eAAO;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF,CAAC;AAAA;AAAA;AAAA;AAAA,EAKD,sBAAkB,sBAAS,MAAM;AAC/B,UAAM,kBAAkB,KAAK,WAAW;AAExC,QAAI,OAAO,oBAAoB,YAAY,oBAAoB,MAAM;AACnE,YAAM,kBAAc;AAAA,QAClB;AAAA,QACA;AAAA,UACE,eAAe,KAAK;AAAA,UACpB,SAAS,KAAK;AAAA,QAChB;AAAA,QACA,KAAK;AAAA,MACP;AAEA,UAAI,OAAO,gBAAgB,UAAU;AACnC,gBAAQ;AAAA,UACN,kDAAkD,OAAO,WAAW,4BAA4B,KAAK;AAAA,YACnG;AAAA,UACF,CAAC;AAAA,QACH;AACA,eAAO,KAAK,SAAS;AAAA,MACvB;AACA,aAAO;AAAA,IACT;AAEA,WAAO,gBAAgB;AAAA,EACzB,CAAC;AACH;","names":["import_core"]}

package/dist/cjs/editor/EditorSelectorRenderer.component.cjs

@@ -0,0 +1,58 @@
+"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 EditorSelectorRenderer_component_exports = {};
+__export(EditorSelectorRenderer_component_exports, {
+  EditorSelectorRendererComponent: () => EditorSelectorRendererComponent
+});
+module.exports = __toCommonJS(EditorSelectorRenderer_component_exports);
+var import_common = require("@angular/common");
+var import_core = require("@angular/core");
+var import_ContentSelectorWrapper = require('./ContentSelectorWrapper.component.cjs');
+var import_EditedContentRenderer = require('./EditedContentRenderer.component.cjs');
+@((0, import_core.Component)({
+  selector: "app-editor-selector-renderer",
+  standalone: true,
+  imports: [
+    import_common.CommonModule,
+    import_ContentSelectorWrapper.ContentSelectorWrapperComponent,
+    import_EditedContentRenderer.EditedContentRendererComponent
+  ],
+  template: `
+    <app-content-selector-wrapper
+      [dictionaryKey]="dictionaryKey"
+      [keyPath]="keyPath"
+    >
+      <app-edited-content-renderer
+        [dictionaryKey]="dictionaryKey"
+        [keyPath]="keyPath"
+      >
+        <ng-content></ng-content>
+      </app-edited-content-renderer>
+    </app-content-selector-wrapper>
+  `
+}))
+class EditorSelectorRendererComponent {
+  @((0, import_core.Input)()) dictionaryKey;
+  @((0, import_core.Input)()) keyPath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EditorSelectorRendererComponent
+});
+//# sourceMappingURL=EditorSelectorRenderer.component.cjs.map

package/dist/cjs/editor/EditorSelectorRenderer.component.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/EditorSelectorRenderer.component.ts"],"sourcesContent":["import { CommonModule } from '@angular/common';\nimport { Component, Input } from '@angular/core';\nimport { type NodeProps } from '@intlayer/core';\nimport { ContentSelectorWrapperComponent } from './ContentSelectorWrapper.component';\nimport { EditedContentRendererComponent } from './EditedContentRenderer.component';\n\n/**\n * Combine your NodeProps (which include dictionaryKey & keyPath)\n * with any other div-like attributes.\n */\nexport interface EditorSelectorRendererProps extends NodeProps {\n  [key: string]: any;\n}\n\n@Component({\n  selector: 'app-editor-selector-renderer',\n  standalone: true,\n  imports: [\n    CommonModule,\n    ContentSelectorWrapperComponent,\n    EditedContentRendererComponent,\n  ],\n  template: `\n    <app-content-selector-wrapper\n      [dictionaryKey]=\"dictionaryKey\"\n      [keyPath]=\"keyPath\"\n    >\n      <app-edited-content-renderer\n        [dictionaryKey]=\"dictionaryKey\"\n        [keyPath]=\"keyPath\"\n      >\n        <ng-content></ng-content>\n      </app-edited-content-renderer>\n    </app-content-selector-wrapper>\n  `,\n})\nexport class EditorSelectorRendererComponent {\n  @Input() dictionaryKey!: string;\n  @Input() keyPath!: any[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6B;AAC7B,kBAAiC;AAEjC,oCAAgD;AAChD,mCAA+C;AAU/C,MAAC,uBAAU;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,SAAS;AAAA,IACP;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAaZ,CAAC;AACM,MAAM,gCAAgC;AAC3C,QAAC,mBAAM,GAAE;AACT,QAAC,mBAAM,GAAE;AACX;","names":[]}

package/dist/cjs/editor/changedContent.cjs

@@ -0,0 +1,62 @@
+"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 changedContent_exports = {};
+__export(changedContent_exports, {
+  createChangedContentClient: () => createChangedContentClient,
+  installChangedContent: () => installChangedContent,
+  useChangedContent: () => useChangedContent
+});
+module.exports = __toCommonJS(changedContent_exports);
+var import_core = require("@angular/core");
+let instance = null;
+const INTLAYER_CHANGED_CONTENT_SYMBOL = Symbol("intlayerChangedContent");
+const createChangedContentClient = () => {
+  if (instance) return instance;
+  const stateSignal = (0, import_core.signal)({});
+  const setChangedContent = (dictionaryKey, newValue) => {
+    const currentState = stateSignal();
+    stateSignal.set({
+      ...currentState,
+      [dictionaryKey]: {
+        ...currentState[dictionaryKey] ?? { key: dictionaryKey, content: {} },
+        content: newValue
+      }
+    });
+  };
+  instance = {
+    get content() {
+      return stateSignal();
+    },
+    setContent: setChangedContent
+  };
+  return instance;
+};
+const installChangedContent = (injector) => {
+  const client = createChangedContentClient();
+};
+const useChangedContent = () => {
+  return createChangedContentClient();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createChangedContentClient,
+  installChangedContent,
+  useChangedContent
+});
+//# sourceMappingURL=changedContent.cjs.map

package/dist/cjs/editor/changedContent.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/changedContent.ts"],"sourcesContent":["import { Injector, signal } from '@angular/core';\nimport type { Dictionary } from '@intlayer/core';\n\n/**\n * Singleton instance\n */\nlet instance: ChangedContent | null = null;\n\nconst INTLAYER_CHANGED_CONTENT_SYMBOL = Symbol('intlayerChangedContent');\n\ntype ChangedContent = {\n  content: Record<Dictionary['key'], Dictionary>;\n  setContent: (key: Dictionary['key'], newValue: Dictionary['content']) => void;\n};\n\nexport const createChangedContentClient = () => {\n  if (instance) return instance;\n\n  const stateSignal = signal<ChangedContent['content']>({});\n\n  /**\n   * Sets the content for a specific dictionary\n   * @param dictionaryKey - The key of the dictionary to update\n   * @param newValue - The new content to set\n   */\n  const setChangedContent = (\n    dictionaryKey: Dictionary['key'],\n    newValue: Dictionary['content']\n  ) => {\n    const currentState = stateSignal();\n    stateSignal.set({\n      ...currentState,\n      [dictionaryKey]: {\n        ...(currentState[dictionaryKey] ?? { key: dictionaryKey, content: {} }),\n        content: newValue,\n      } as Dictionary,\n    });\n  };\n\n  instance = {\n    get content() {\n      return stateSignal();\n    },\n    setContent: setChangedContent,\n  };\n\n  return instance;\n};\n\n/**\n * Helper to install the Intlayer provider into the injector\n */\nexport const installChangedContent = (injector: Injector) => {\n  const client = createChangedContentClient();\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 createChangedContentClient\n};\n\nexport const useChangedContent = () => {\n  return createChangedContentClient();\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAiC;AAMjC,IAAI,WAAkC;AAEtC,MAAM,kCAAkC,OAAO,wBAAwB;AAOhE,MAAM,6BAA6B,MAAM;AAC9C,MAAI,SAAU,QAAO;AAErB,QAAM,kBAAc,oBAAkC,CAAC,CAAC;AAOxD,QAAM,oBAAoB,CACxB,eACA,aACG;AACH,UAAM,eAAe,YAAY;AACjC,gBAAY,IAAI;AAAA,MACd,GAAG;AAAA,MACH,CAAC,aAAa,GAAG;AAAA,QACf,GAAI,aAAa,aAAa,KAAK,EAAE,KAAK,eAAe,SAAS,CAAC,EAAE;AAAA,QACrE,SAAS;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH;AAEA,aAAW;AAAA,IACT,IAAI,UAAU;AACZ,aAAO,YAAY;AAAA,IACrB;AAAA,IACA,YAAY;AAAA,EACd;AAEA,SAAO;AACT;AAKO,MAAM,wBAAwB,CAAC,aAAuB;AAC3D,QAAM,SAAS,2BAA2B;AAI5C;AAEO,MAAM,oBAAoB,MAAM;AACrC,SAAO,2BAA2B;AACpC;","names":[]}

package/dist/cjs/editor/communicator.cjs

@@ -0,0 +1,82 @@
+"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 communicator_exports = {};
+__export(communicator_exports, {
+  createCommunicator: () => createCommunicator,
+  installCommunicator: () => installCommunicator,
+  useCommunicator: () => useCommunicator
+});
+module.exports = __toCommonJS(communicator_exports);
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_uuid = require("uuid");
+const { editor } = import_built.default;
+const defaultValue = {
+  postMessage: () => null,
+  allowedOrigins: [
+    editor?.applicationURL,
+    editor?.editorURL,
+    editor?.cmsURL
+  ],
+  senderId: ""
+};
+let instance = null;
+const INTLAYER_COMMUNICATOR_SYMBOL = Symbol("Communicator");
+const createCommunicator = (options = { postMessage: () => null }) => {
+  if (instance) return instance;
+  instance = {
+    ...defaultValue,
+    ...options,
+    senderId: (0, import_uuid.v4)()
+  };
+  return instance;
+};
+const installCommunicator = (injector, options = { postMessage: () => null }) => {
+  const client = createCommunicator(options);
+};
+const useCommunicator = () => {
+  try {
+    const communicator = createCommunicator();
+    return communicator || defaultValue;
+  } catch (error) {
+    console.warn(
+      "useCommunicator: Error accessing communicator. Returning default communicator."
+    );
+    return {
+      postMessage: () => null,
+      senderId: ""
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCommunicator,
+  installCommunicator,
+  useCommunicator
+});
+//# sourceMappingURL=communicator.cjs.map

package/dist/cjs/editor/communicator.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/communicator.ts"],"sourcesContent":["import { Injector } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport { v4 as uuid } from 'uuid';\n\n/**\n * Interface defining a cross-frame communicator\n */\nexport type Communicator = {\n  postMessage: typeof window.postMessage;\n  allowedOrigins?: string[];\n  senderId: string;\n};\n\n/**\n * Configuration options for the communicator\n */\nexport type CommunicatorOptions = Omit<Communicator, 'senderId'>;\n\nconst { editor } = configuration;\n\n/**\n * Default values for the communicator\n */\nconst defaultValue: Communicator = {\n  postMessage: () => null,\n  allowedOrigins: [\n    editor?.applicationURL,\n    editor?.editorURL,\n    editor?.cmsURL,\n  ] as string[],\n  senderId: '',\n};\n\n/**\n * Singleton instance\n */\nlet instance: Communicator | null = null;\n\nconst INTLAYER_COMMUNICATOR_SYMBOL = Symbol('Communicator');\n\n/**\n * Creates a communicator client\n * @param options - Options for configuring the communicator\n */\nexport const createCommunicator = (\n  options: CommunicatorOptions = { postMessage: () => null }\n) => {\n  if (instance) return instance;\n\n  instance = {\n    ...defaultValue,\n    ...options,\n    senderId: uuid(),\n  };\n\n  return instance;\n};\n\n/**\n * Helper to install the Intlayer communicator into the injector\n */\nexport const installCommunicator = (\n  injector: Injector,\n  options: CommunicatorOptions = { postMessage: () => null }\n) => {\n  const client = createCommunicator(options);\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 createCommunicator\n};\n\n/**\n * Hook to access the communicator\n * @returns The communicator instance\n */\nexport const useCommunicator = (): Communicator => {\n  try {\n    const communicator = createCommunicator();\n    return communicator || defaultValue;\n  } catch (error) {\n    console.warn(\n      'useCommunicator: Error accessing communicator. Returning default communicator.'\n    );\n    return {\n      postMessage: () => null,\n      senderId: '',\n    };\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,mBAA0B;AAC1B,kBAA2B;AAgB3B,MAAM,EAAE,OAAO,IAAI,aAAAA;AAKnB,MAAM,eAA6B;AAAA,EACjC,aAAa,MAAM;AAAA,EACnB,gBAAgB;AAAA,IACd,QAAQ;AAAA,IACR,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAAA,EACA,UAAU;AACZ;AAKA,IAAI,WAAgC;AAEpC,MAAM,+BAA+B,OAAO,cAAc;AAMnD,MAAM,qBAAqB,CAChC,UAA+B,EAAE,aAAa,MAAM,KAAK,MACtD;AACH,MAAI,SAAU,QAAO;AAErB,aAAW;AAAA,IACT,GAAG;AAAA,IACH,GAAG;AAAA,IACH,cAAU,YAAAC,IAAK;AAAA,EACjB;AAEA,SAAO;AACT;AAKO,MAAM,sBAAsB,CACjC,UACA,UAA+B,EAAE,aAAa,MAAM,KAAK,MACtD;AACH,QAAM,SAAS,mBAAmB,OAAO;AAI3C;AAMO,MAAM,kBAAkB,MAAoB;AACjD,MAAI;AACF,UAAM,eAAe,mBAAmB;AACxC,WAAO,gBAAgB;AAAA,EACzB,SAAS,OAAO;AACd,YAAQ;AAAA,MACN;AAAA,IACF;AACA,WAAO;AAAA,MACL,aAAa,MAAM;AAAA,MACnB,UAAU;AAAA,IACZ;AAAA,EACF;AACF;","names":["configuration","uuid"]}

package/dist/cjs/editor/configuration.cjs

@@ -0,0 +1,57 @@
+"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 configuration_exports = {};
+__export(configuration_exports, {
+  useConfiguration: () => useConfiguration
+});
+module.exports = __toCommonJS(configuration_exports);
+var import_core = require("@angular/core");
+var import_built = __toESM(require("@intlayer/config/built"));
+var import_editor = require("@intlayer/editor");
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+const useConfiguration = () => {
+  const [pushedConfiguration, setConfiguration] = (0, import_useCrossFrameState.useCrossFrameState)(import_editor.MessageKey.INTLAYER_CONFIGURATION);
+  try {
+    const destroyRef = (0, import_core.inject)(import_core.DestroyRef, { optional: true });
+    if (destroyRef) {
+      if (!pushedConfiguration()) {
+        setConfiguration(import_built.default);
+      }
+    }
+  } catch {
+    console.warn(
+      "useConfiguration called outside injection context; configuration may not be synchronized."
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useConfiguration
+});
+//# sourceMappingURL=configuration.cjs.map

package/dist/cjs/editor/configuration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/configuration.ts"],"sourcesContent":["import { DestroyRef, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport { IntlayerConfig } from '@intlayer/config/client';\nimport { MessageKey } from '@intlayer/editor';\nimport { useCrossFrameState } from './useCrossFrameState';\n\nexport const useConfiguration = () => {\n  const [pushedConfiguration, setConfiguration] =\n    useCrossFrameState<IntlayerConfig>(MessageKey.INTLAYER_CONFIGURATION);\n\n  // Use Angular's injection context instead of Vue's onMounted\n  try {\n    const destroyRef = inject(DestroyRef, { optional: true });\n\n    if (destroyRef) {\n      // Execute immediately since Angular doesn't have the same lifecycle hooks\n      if (!pushedConfiguration()) {\n        setConfiguration(configuration);\n      }\n    }\n  } catch {\n    console.warn(\n      'useConfiguration called outside injection context; ' +\n        'configuration may not be synchronized.'\n    );\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAmC;AACnC,mBAA0B;AAE1B,oBAA2B;AAC3B,gCAAmC;AAE5B,MAAM,mBAAmB,MAAM;AACpC,QAAM,CAAC,qBAAqB,gBAAgB,QAC1C,8CAAmC,yBAAW,sBAAsB;AAGtE,MAAI;AACF,UAAM,iBAAa,oBAAO,wBAAY,EAAE,UAAU,KAAK,CAAC;AAExD,QAAI,YAAY;AAEd,UAAI,CAAC,oBAAoB,GAAG;AAC1B,yBAAiB,aAAAA,OAAa;AAAA,MAChC;AAAA,IACF;AAAA,EACF,QAAQ;AACN,YAAQ;AAAA,MACN;AAAA,IAEF;AAAA,EACF;AACF;","names":["configuration"]}

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