angular-intlayer 5.5.8 → 5.5.10

package/dist/esm/client/useLocale.mjs

@@ -0,0 +1,35 @@
+import { computed, inject } from "@angular/core";
+import configuration from "@intlayer/config/built";
+import { INTLAYER_TOKEN } from "./installIntlayer.mjs";
+import { useLocaleCookie } from "./useLocaleCookie.mjs";
+const useLocale = ({ onLocaleChange } = {}) => {
+  const { defaultLocale, locales: availableLocales } = configuration?.internationalization ?? {};
+  const intlayer = inject(INTLAYER_TOKEN);
+  const { setLocaleCookie } = useLocaleCookie();
+  const locale = computed(() => intlayer?.locale() ?? defaultLocale);
+  const setLocale = (newLocale) => {
+    if (!availableLocales?.map(String).includes(newLocale)) {
+      console.error(`Locale ${newLocale} is not available`);
+      return;
+    }
+    if (intlayer) {
+      intlayer.setLocale(newLocale);
+    }
+    setLocaleCookie(newLocale);
+    onLocaleChange?.(newLocale);
+  };
+  return {
+    locale,
+    // Current locale
+    defaultLocale,
+    // Principal locale defined in config
+    availableLocales,
+    // List of the available locales defined in config
+    setLocale
+    // Function to set the locale
+  };
+};
+export {
+  useLocale
+};
+//# sourceMappingURL=useLocale.mjs.map

package/dist/esm/client/useLocale.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/client/useLocale.ts"],"sourcesContent":["import { computed, inject } from '@angular/core';\nimport configuration from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/config/client';\nimport { INTLAYER_TOKEN, IntlayerProvider } from './installIntlayer';\nimport { useLocaleCookie } from './useLocaleCookie';\n\ntype useLocaleProps = {\n  onLocaleChange?: (locale: LocalesValues) => void;\n};\n\n/**\n * On the client side, composable to get the current locale and all related fields\n */\nexport const useLocale = ({ onLocaleChange }: useLocaleProps = {}) => {\n  const { defaultLocale, locales: availableLocales } =\n    configuration?.internationalization ?? {};\n  const intlayer = inject<IntlayerProvider>(INTLAYER_TOKEN);\n  const { setLocaleCookie } = useLocaleCookie();\n\n  // Create a reactive reference for the locale\n  const locale = computed(() => intlayer?.locale() ?? defaultLocale);\n\n  const setLocale = (newLocale: LocalesValues) => {\n    if (!availableLocales?.map(String).includes(newLocale)) {\n      console.error(`Locale ${newLocale} is not available`);\n      return;\n    }\n\n    if (intlayer) {\n      intlayer.setLocale(newLocale);\n    }\n    setLocaleCookie(newLocale);\n    onLocaleChange?.(newLocale);\n  };\n\n  return {\n    locale, // Current locale\n    defaultLocale, // Principal locale defined in config\n    availableLocales, // List of the available locales defined in config\n    setLocale, // Function to set the locale\n  };\n};\n"],"mappings":"AAAA,SAAS,UAAU,cAAc;AACjC,OAAO,mBAAmB;AAE1B,SAAS,sBAAwC;AACjD,SAAS,uBAAuB;AASzB,MAAM,YAAY,CAAC,EAAE,eAAe,IAAoB,CAAC,MAAM;AACpE,QAAM,EAAE,eAAe,SAAS,iBAAiB,IAC/C,eAAe,wBAAwB,CAAC;AAC1C,QAAM,WAAW,OAAyB,cAAc;AACxD,QAAM,EAAE,gBAAgB,IAAI,gBAAgB;AAG5C,QAAM,SAAS,SAAS,MAAM,UAAU,OAAO,KAAK,aAAa;AAEjE,QAAM,YAAY,CAAC,cAA6B;AAC9C,QAAI,CAAC,kBAAkB,IAAI,MAAM,EAAE,SAAS,SAAS,GAAG;AACtD,cAAQ,MAAM,UAAU,SAAS,mBAAmB;AACpD;AAAA,IACF;AAEA,QAAI,UAAU;AACZ,eAAS,UAAU,SAAS;AAAA,IAC9B;AACA,oBAAgB,SAAS;AACzB,qBAAiB,SAAS;AAAA,EAC5B;AAEA,SAAO;AAAA,IACL;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,IACA;AAAA;AAAA,EACF;AACF;","names":[]}

package/dist/esm/client/useLocaleCookie.mjs

@@ -0,0 +1,24 @@
+import configuration from "@intlayer/config/built";
+import Cookies from "js-cookie";
+const { cookieName } = configuration.middleware;
+const cookieAttributes = {
+  path: "/",
+  expires: void 0,
+  domain: void 0,
+  secure: false,
+  sameSite: "strict"
+};
+const localeCookie = Cookies.get(cookieName);
+const setLocaleCookie = (locale) => {
+  Cookies.set(cookieName, locale, cookieAttributes);
+};
+const useLocaleCookie = () => ({
+  localeCookie,
+  setLocaleCookie
+});
+export {
+  localeCookie,
+  setLocaleCookie,
+  useLocaleCookie
+};
+//# sourceMappingURL=useLocaleCookie.mjs.map

package/dist/esm/client/useLocaleCookie.mjs.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,OAAO,mBAAmB;AAG1B,OAAO,aAAa;AAEpB,MAAM,EAAE,WAAW,IAAI,cAAc;AAErC,MAAM,mBAA6C;AAAA,EACjD,MAAM;AAAA,EACN,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,UAAU;AACZ;AAKO,MAAM,eAAe,QAAQ,IAAI,UAAU;AAO3C,MAAM,kBAAkB,CAAC,WAA0B;AACxD,UAAQ,IAAI,YAAY,QAAQ,gBAAgB;AAClD;AAKO,MAAM,kBAAkB,OAAO;AAAA,EACpC;AAAA,EACA;AACF;","names":[]}

package/dist/esm/editor/ContentSelectorWrapper.component.mjs

@@ -0,0 +1,49 @@
+import { CommonModule } from "@angular/common";
+import { Component, Input, computed } from "@angular/core";
+import { isSameKeyPath } from "@intlayer/core";
+import { ContentSelectorComponent } from "../UI/ContentSelector.component.mjs";
+import { useEditorEnabled } from "./editorEnabled.mjs";
+import { useFocusDictionary } from "./focusDictionary.mjs";
+import { useEditor } from "./useEditor.mjs";
+@Component({
+  selector: "app-content-selector-wrapper",
+  standalone: true,
+  imports: [CommonModule, 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 {
+  @Input() dictionaryKey;
+  @Input() keyPath;
+  // pull in the editor state & focus API
+  focusDictionary = useFocusDictionary();
+  editorEnabled = useEditorEnabled();
+  constructor() {
+    useEditor();
+  }
+  // compute whether this node is the current focus
+  isSelected = computed(() => {
+    const focusedContent = this.focusDictionary.focusedContent();
+    return focusedContent?.dictionaryKey === this.dictionaryKey && (focusedContent.keyPath?.length ?? 0) > 0 && isSameKeyPath(focusedContent.keyPath ?? [], this.keyPath);
+  });
+  enabled = computed(() => this.editorEnabled.enabled());
+  // when the selector is clicked, update focus
+  handleSelect() {
+    this.focusDictionary.setFocusedContent({
+      dictionaryKey: this.dictionaryKey,
+      keyPath: this.keyPath
+    });
+  }
+}
+export {
+  ContentSelectorWrapperComponent
+};
+//# sourceMappingURL=ContentSelectorWrapper.component.mjs.map

package/dist/esm/editor/ContentSelectorWrapper.component.mjs.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,SAAS,oBAAoB;AAC7B,SAAS,WAAW,OAAO,gBAAgB;AAC3C,SAAS,qBAAqC;AAC9C,SAAS,gCAAgC;AACzC,SAAS,wBAAwB;AACjC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAU1B,CAAC,UAAU;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,SAAS,CAAC,cAAc,wBAAwB;AAAA,EAChD,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUZ,CAAC;AACM,MAAM,gCAAgC;AAC3C,GAAC,MAAM,EAAE;AACT,GAAC,MAAM,EAAE;AAAA;AAAA,EAGD,kBAAkB,mBAAmB;AAAA,EACrC,gBAAgB,iBAAiB;AAAA,EAEzC,cAAc;AACZ,cAAU;AAAA,EACZ;AAAA;AAAA,EAGA,aAAa,SAAS,MAAM;AAC1B,UAAM,iBAAiB,KAAK,gBAAgB,eAAe;AAC3D,WACE,gBAAgB,kBAAkB,KAAK,kBACtC,eAAe,SAAS,UAAU,KAAK,KACxC,cAAc,eAAe,WAAW,CAAC,GAAG,KAAK,OAAO;AAAA,EAE5D,CAAC;AAAA,EAED,UAAU,SAAS,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":[]}

package/dist/esm/editor/EditedContentRenderer.component.mjs

@@ -0,0 +1,53 @@
+import { CommonModule } from "@angular/common";
+import { Component, Input, computed, signal } from "@angular/core";
+import { getContent } from "@intlayer/core";
+import { useEditedContentRenderer } from "./useEditedContentRenderer.mjs";
+@Component({
+  selector: "app-edited-content-renderer",
+  standalone: true,
+  imports: [CommonModule],
+  template: ` <span [innerHTML]="renderedContent()"></span> `
+})
+class EditedContentRendererComponent {
+  @Input() dictionaryKey;
+  @Input() keyPath;
+  @Input() locale;
+  fallback = signal("");
+  rawContent = computed(() => {
+    return useEditedContentRenderer(
+      this.dictionaryKey,
+      this.keyPath,
+      this.fallback
+    );
+  });
+  /**
+   * Object → getContent → string, same as the React version.
+   */
+  renderedContent = computed(() => {
+    const rawContentValue = this.rawContent();
+    if (typeof rawContentValue === "object" && rawContentValue !== null) {
+      const transformed = 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();
+  });
+}
+export {
+  EditedContentRendererComponent
+};
+//# sourceMappingURL=EditedContentRenderer.component.mjs.map

package/dist/esm/editor/EditedContentRenderer.component.mjs.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,SAAS,oBAAoB;AAC7B,SAAS,WAAW,OAAO,UAAU,cAAc;AAEnD,SAAsB,kBAAgC;AACtD,SAAS,gCAAgC;AAQzC,CAAC,UAAU;AAAA,EACT,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,SAAS,CAAC,YAAY;AAAA,EACtB,UAAU;AACZ,CAAC;AACM,MAAM,+BAA+B;AAC1C,GAAC,MAAM,EAAE;AACT,GAAC,MAAM,EAAE;AACT,GAAC,MAAM,EAAE;AAAA,EAED,WAAW,OAAO,EAAE;AAAA,EAEpB,aAAa,SAAS,MAAM;AAClC,WAAO;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF,CAAC;AAAA;AAAA;AAAA;AAAA,EAKD,kBAAkB,SAAS,MAAM;AAC/B,UAAM,kBAAkB,KAAK,WAAW;AAExC,QAAI,OAAO,oBAAoB,YAAY,oBAAoB,MAAM;AACnE,YAAM,cAAc;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":[]}

package/dist/esm/editor/EditorSelectorRenderer.component.mjs

@@ -0,0 +1,34 @@
+import { CommonModule } from "@angular/common";
+import { Component, Input } from "@angular/core";
+import { ContentSelectorWrapperComponent } from "./ContentSelectorWrapper.component.mjs";
+import { EditedContentRendererComponent } from "./EditedContentRenderer.component.mjs";
+@Component({
+  selector: "app-editor-selector-renderer",
+  standalone: true,
+  imports: [
+    CommonModule,
+    ContentSelectorWrapperComponent,
+    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 {
+  @Input() dictionaryKey;
+  @Input() keyPath;
+}
+export {
+  EditorSelectorRendererComponent
+};
+//# sourceMappingURL=EditorSelectorRenderer.component.mjs.map

package/dist/esm/editor/EditorSelectorRenderer.component.mjs.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,SAAS,oBAAoB;AAC7B,SAAS,WAAW,aAAa;AAEjC,SAAS,uCAAuC;AAChD,SAAS,sCAAsC;AAU/C,CAAC,UAAU;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,GAAC,MAAM,EAAE;AACT,GAAC,MAAM,EAAE;AACX;","names":[]}

package/dist/esm/editor/changedContent.mjs

@@ -0,0 +1,36 @@
+import { signal } from "@angular/core";
+let instance = null;
+const INTLAYER_CHANGED_CONTENT_SYMBOL = Symbol("intlayerChangedContent");
+const createChangedContentClient = () => {
+  if (instance) return instance;
+  const stateSignal = 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();
+};
+export {
+  createChangedContentClient,
+  installChangedContent,
+  useChangedContent
+};
+//# sourceMappingURL=changedContent.mjs.map

package/dist/esm/editor/changedContent.mjs.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,SAAmB,cAAc;AAMjC,IAAI,WAAkC;AAEtC,MAAM,kCAAkC,OAAO,wBAAwB;AAOhE,MAAM,6BAA6B,MAAM;AAC9C,MAAI,SAAU,QAAO;AAErB,QAAM,cAAc,OAAkC,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/esm/editor/communicator.mjs

@@ -0,0 +1,46 @@
+import configuration from "@intlayer/config/built";
+import { v4 as uuid } from "uuid";
+const { editor } = configuration;
+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: uuid()
+  };
+  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: ""
+    };
+  }
+};
+export {
+  createCommunicator,
+  installCommunicator,
+  useCommunicator
+};
+//# sourceMappingURL=communicator.mjs.map

package/dist/esm/editor/communicator.mjs.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":"AACA,OAAO,mBAAmB;AAC1B,SAAS,MAAM,YAAY;AAgB3B,MAAM,EAAE,OAAO,IAAI;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,UAAU,KAAK;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":[]}

package/dist/esm/editor/configuration.mjs

@@ -0,0 +1,23 @@
+import { DestroyRef, inject } from "@angular/core";
+import configuration from "@intlayer/config/built";
+import { MessageKey } from "@intlayer/editor";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+const useConfiguration = () => {
+  const [pushedConfiguration, setConfiguration] = useCrossFrameState(MessageKey.INTLAYER_CONFIGURATION);
+  try {
+    const destroyRef = inject(DestroyRef, { optional: true });
+    if (destroyRef) {
+      if (!pushedConfiguration()) {
+        setConfiguration(configuration);
+      }
+    }
+  } catch {
+    console.warn(
+      "useConfiguration called outside injection context; configuration may not be synchronized."
+    );
+  }
+};
+export {
+  useConfiguration
+};
+//# sourceMappingURL=configuration.mjs.map

package/dist/esm/editor/configuration.mjs.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,SAAS,YAAY,cAAc;AACnC,OAAO,mBAAmB;AAE1B,SAAS,kBAAkB;AAC3B,SAAS,0BAA0B;AAE5B,MAAM,mBAAmB,MAAM;AACpC,QAAM,CAAC,qBAAqB,gBAAgB,IAC1C,mBAAmC,WAAW,sBAAsB;AAGtE,MAAI;AACF,UAAM,aAAa,OAAO,YAAY,EAAE,UAAU,KAAK,CAAC;AAExD,QAAI,YAAY;AAEd,UAAI,CAAC,oBAAoB,GAAG;AAC1B,yBAAiB,aAAa;AAAA,MAChC;AAAA,IACF;AAAA,EACF,QAAQ;AACN,YAAQ;AAAA,MACN;AAAA,IAEF;AAAA,EACF;AACF;","names":[]}

package/dist/esm/editor/createSharedComposable.mjs

@@ -0,0 +1,43 @@
+import { DestroyRef, inject } from "@angular/core";
+function tryOnScopeDispose(fn) {
+  try {
+    const destroyRef = inject(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;
+  };
+};
+export {
+  createSharedComposable,
+  tryOnScopeDispose
+};
+//# sourceMappingURL=createSharedComposable.mjs.map

package/dist/esm/editor/createSharedComposable.mjs.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,SAAS,YAAY,cAAc;AAU5B,SAAS,kBAAkB,IAAgB;AAChD,MAAI;AACF,UAAM,aAAa,OAAO,YAAY,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/esm/editor/dictionariesRecord.mjs

@@ -0,0 +1,47 @@
+import { effect, signal } from "@angular/core";
+import dictionaries from "@intlayer/dictionaries-entry";
+import { MessageKey } from "@intlayer/editor";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+let instance = null;
+const createDictionaryRecordClient = () => {
+  if (instance) return instance;
+  const localeDictionariesSignal = signal(dictionaries);
+  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 = createSharedComposable(() => {
+  const client = createDictionaryRecordClient();
+  if (!client) {
+    throw new Error("DictionariesRecord state not found");
+  }
+  const [_dictionariesRecord, setDictionariesRecord] = useCrossFrameState(
+    MessageKey.INTLAYER_LOCALE_DICTIONARIES_CHANGED,
+    void 0
+  );
+  effect(() => {
+    const newValue = client.localeDictionaries();
+    setDictionariesRecord(newValue);
+  });
+});
+export {
+  createDictionaryRecordClient,
+  installDictionariesRecord,
+  useDictionariesRecord
+};
+//# sourceMappingURL=dictionariesRecord.mjs.map

package/dist/esm/editor/dictionariesRecord.mjs.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,SAAS,QAAkB,cAAsB;AAEjD,OAAO,kBAAkB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,8BAA8B;AACvC,SAAS,0BAA0B;AAKnC,IAAI,WAA4C;AAUzC,MAAM,+BAA+B,MAAM;AAChD,MAAI,SAAU,QAAO;AAErB,QAAM,2BAA2B,OAA0B,YAAY;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,wBAAwB,uBAAuB,MAAM;AAChE,QAAM,SAAS,6BAA6B;AAE5C,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,oCAAoC;AAAA,EACtD;AAEA,QAAM,CAAC,qBAAqB,qBAAqB,IAC/C;AAAA,IACE,WAAW;AAAA,IACX;AAAA,EACF;AAGF,SAAO,MAAM;AACX,UAAM,WAAW,OAAO,mBAAmB;AAC3C,0BAAsB,QAAQ;AAAA,EAChC,CAAC;AACH,CAAC;","names":[]}

package/dist/esm/editor/editedContent.mjs

@@ -0,0 +1,51 @@
+import { effect, signal } from "@angular/core";
+import { getContentNodeByKeyPath } from "@intlayer/core";
+import { MessageKey } from "@intlayer/editor";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+let instance = null;
+const INTLAYER_EDITED_CONTENT_SYMBOL = Symbol("EditedContent");
+const createEditedContentClient = () => {
+  if (instance) return instance;
+  const editedContentSignal = signal({});
+  instance = {
+    editedContent: editedContentSignal.asReadonly(),
+    getEditedContentValue: (dictionaryKey, keyPath) => {
+      const content = editedContentSignal()?.[dictionaryKey]?.content;
+      if (!content) return void 0;
+      return getContentNodeByKeyPath(content, keyPath);
+    },
+    setEditedContent: (editedContent) => {
+      editedContentSignal.set(editedContent);
+    }
+  };
+  return instance;
+};
+const installEditedContent = (injector) => {
+  const client = createEditedContentClient();
+};
+const useEditedContent = createSharedComposable(() => {
+  const client = createEditedContentClient();
+  if (!client) {
+    throw new Error("EditedContent state not found");
+  }
+  const [edited, setEdited] = useCrossFrameState(
+    MessageKey.INTLAYER_EDITED_CONTENT_CHANGED,
+    {}
+  );
+  effect(() => {
+    const newValue = edited();
+    client.setEditedContent(newValue ?? {});
+  });
+  effect(() => {
+    const newValue = client.editedContent();
+    setEdited(newValue);
+  });
+  return client;
+});
+export {
+  createEditedContentClient,
+  installEditedContent,
+  useEditedContent
+};
+//# sourceMappingURL=editedContent.mjs.map

package/dist/esm/editor/editedContent.mjs.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,SAAS,QAAkB,cAAsB;AAEjD,SAAS,+BAA+B;AACxC,SAAS,kBAAkB;AAC3B,SAAS,8BAA8B;AACvC,SAAS,0BAA0B;AAgBnC,IAAI,WAAuC;AAE3C,MAAM,iCAAiC,OAAO,eAAe;AAKtD,MAAM,4BAA4B,MAAM;AAC7C,MAAI,SAAU,QAAO;AAErB,QAAM,sBAAsB,OAAsB,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,aAAO,wBAAwB,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,mBAAmB,uBAAuB,MAAM;AAC3D,QAAM,SAAS,0BAA0B;AAEzC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AAEA,QAAM,CAAC,QAAQ,SAAS,IAAI;AAAA,IAC1B,WAAW;AAAA,IACX,CAAC;AAAA,EACH;AAGA,SAAO,MAAM;AACX,UAAM,WAAW,OAAO;AACxB,WAAO,iBAAiB,YAAY,CAAC,CAAC;AAAA,EACxC,CAAC;AAED,SAAO,MAAM;AACX,UAAM,WAAW,OAAO,cAAc;AACtC,cAAU,QAAQ;AAAA,EACpB,CAAC;AAED,SAAO;AACT,CAAC;","names":[]}

package/dist/esm/editor/editorEnabled.mjs

@@ -0,0 +1,50 @@
+import { computed, effect, signal } from "@angular/core";
+import { MessageKey } from "@intlayer/editor";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameMessageListener } from "./useCrossFrameMessageListener.mjs";
+let instance = null;
+const INTLAYER_EDITOR_ENABLED_SYMBOL = Symbol("EditorEnabled");
+const createEditorEnabledClient = () => {
+  if (instance) return instance;
+  const wrapperEnabledSignal = signal(false);
+  const isInIframeSignal = signal(false);
+  const enabledSignal = computed(
+    () => wrapperEnabledSignal() && isInIframeSignal()
+  );
+  instance = {
+    wrapperEnabled: wrapperEnabledSignal.asReadonly(),
+    isInIframe: isInIframeSignal.asReadonly(),
+    enabled: enabledSignal
+  };
+  return instance;
+};
+const installEditorEnabled = (injector) => {
+  const client = createEditorEnabledClient();
+};
+const useEditorEnabled = createSharedComposable(() => {
+  const client = createEditorEnabledClient();
+  if (!client) {
+    throw new Error("EditorEnabled state not found");
+  }
+  useCrossFrameMessageListener(
+    `${MessageKey.INTLAYER_EDITOR_ENABLED}/post`,
+    (data) => {
+      client.wrapperEnabled.set(data);
+    }
+  );
+  effect(
+    () => {
+      if (typeof window !== "undefined") {
+        client.isInIframe.set(window.self !== window.top);
+      }
+    },
+    { allowSignalWrites: true }
+  );
+  return client;
+});
+export {
+  createEditorEnabledClient,
+  installEditorEnabled,
+  useEditorEnabled
+};
+//# sourceMappingURL=editorEnabled.mjs.map

package/dist/esm/editor/editorEnabled.mjs.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,SAAS,UAAU,QAAkB,cAAsB;AAC3D,SAAS,kBAAkB;AAC3B,SAAS,8BAA8B;AACvC,SAAS,oCAAoC;AAc7C,IAAI,WAA2C;AAE/C,MAAM,iCAAiC,OAAO,eAAe;AAKtD,MAAM,4BAA4B,MAAM;AAC7C,MAAI,SAAU,QAAO;AAErB,QAAM,uBAAuB,OAAO,KAAK;AACzC,QAAM,mBAAmB,OAAO,KAAK;AACrC,QAAM,gBAAgB;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,mBAAmB,uBAAuB,MAAM;AAC3D,QAAM,SAAS,0BAA0B;AAEzC,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,+BAA+B;AAAA,EACjD;AAGA;AAAA,IACE,GAAG,WAAW,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/esm/editor/editorLocale.mjs

@@ -0,0 +1,23 @@
+import { effect, inject } from "@angular/core";
+import { MessageKey } from "@intlayer/editor";
+import { INTLAYER_TOKEN } from "../client/index.mjs";
+import { createSharedComposable } from "./createSharedComposable.mjs";
+import { useCrossFrameState } from "./useCrossFrameState.mjs";
+const useEditorLocale = createSharedComposable(() => {
+  const client = inject(INTLAYER_TOKEN);
+  if (!client) {
+    throw new Error("IntlayerEditor state not found");
+  }
+  const [_data, setData] = useCrossFrameState(
+    MessageKey.INTLAYER_CURRENT_LOCALE
+  );
+  effect(() => {
+    const newValue = client.locale();
+    setData(newValue);
+  });
+  return client;
+});
+export {
+  useEditorLocale
+};
+//# sourceMappingURL=editorLocale.mjs.map

package/dist/esm/editor/editorLocale.mjs.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,SAAS,QAAQ,cAAc;AAE/B,SAAS,kBAAkB;AAC3B,SAAS,sBAAwC;AACjD,SAAS,8BAA8B;AACvC,SAAS,0BAA0B;AAE5B,MAAM,kBAAkB,uBAAuB,MAAM;AAC1D,QAAM,SAAS,OAAyB,cAAc;AAEtD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,MAAM,gCAAgC;AAAA,EAClD;AAEA,QAAM,CAAC,OAAO,OAAO,IAAI;AAAA,IACvB,WAAW;AAAA,EACb;AAGA,SAAO,MAAM;AACX,UAAM,WAAW,OAAO,OAAO;AAC/B,YAAQ,QAAQ;AAAA,EAClB,CAAC;AAED,SAAO;AACT,CAAC;","names":[]}