angular-intlayer 5.5.9 → 5.5.10

package/dist/cjs/editor/useCrossFrameState.cjs

@@ -0,0 +1,95 @@
+"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 useCrossFrameState_exports = {};
+__export(useCrossFrameState_exports, {
+  useCrossFrameState: () => useCrossFrameState
+});
+module.exports = __toCommonJS(useCrossFrameState_exports);
+var import_core = require("@angular/core");
+var import_communicator = require('./communicator.cjs');
+var import_useCrossFrameMessageListener = require('./useCrossFrameMessageListener.cjs');
+const crossFrameStateCache = /* @__PURE__ */ new Map();
+const resolveState = (state, prevState) => {
+  if (typeof state === "function") {
+    return state(prevState);
+  }
+  return state;
+};
+const toSerializable = (obj) => {
+  if (obj === null || obj === void 0) return obj;
+  return JSON.parse(JSON.stringify(obj));
+};
+const useCrossFrameState = (key, initialState, options = { emit: true, receive: true }) => {
+  if (crossFrameStateCache.has(key)) {
+    const { state, setState: setState2, postState: postState2 } = crossFrameStateCache.get(key);
+    return [state, setState2, postState2];
+  }
+  const { emit = true, receive = true } = options;
+  const stateSignal = (0, import_core.signal)(resolveState(initialState));
+  const { postMessage, senderId } = (0, import_communicator.useCommunicator)();
+  const broadcastState = (value) => {
+    if (!emit || typeof postMessage !== "function" || typeof value === "undefined")
+      return;
+    postMessage({
+      type: `${key}/post`,
+      data: value,
+      senderId
+    });
+  };
+  const setState = (valueOrUpdater) => {
+    const next = resolveState(valueOrUpdater, stateSignal());
+    const serialised = toSerializable(next);
+    stateSignal.set(serialised);
+    broadcastState(serialised);
+  };
+  const postState = () => {
+    if (typeof postMessage !== "function") return;
+    postMessage({
+      type: `${key}/post`,
+      data: stateSignal(),
+      senderId
+    });
+  };
+  broadcastState(stateSignal());
+  if (receive && typeof postMessage === "function" && typeof stateSignal() === "undefined") {
+    postMessage({ type: `${key}/get`, senderId });
+  }
+  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    `${key}/post`,
+    receive ? (data) => {
+      stateSignal.set(data);
+    } : void 0
+  );
+  const handleGetMessage = (_, originSenderId) => {
+    if (!emit) return;
+    if (originSenderId === senderId) return;
+    broadcastState(stateSignal());
+  };
+  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    `${key}/get`,
+    emit ? handleGetMessage : void 0
+  );
+  crossFrameStateCache.set(key, { state: stateSignal, setState, postState });
+  return [stateSignal, setState, postState];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCrossFrameState
+});
+//# sourceMappingURL=useCrossFrameState.cjs.map

package/dist/cjs/editor/useCrossFrameState.cjs.map

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

package/dist/cjs/editor/useCrossURLPathState.cjs

@@ -0,0 +1,72 @@
+"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 useCrossURLPathState_exports = {};
+__export(useCrossURLPathState_exports, {
+  useCrossURLPathSetter: () => useCrossURLPathSetter,
+  useCrossURLPathState: () => useCrossURLPathState
+});
+module.exports = __toCommonJS(useCrossURLPathState_exports);
+var import_core = require("@angular/core");
+var import_editor = require("@intlayer/editor");
+var import_useCrossFrameState = require('./useCrossFrameState.cjs');
+const useCrossURLPathState = (initial, opts) => (0, import_useCrossFrameState.useCrossFrameState)(import_editor.MessageKey.INTLAYER_URL_CHANGE, initial, opts);
+const useCrossURLPathSetter = (initial) => {
+  const [state, setState] = useCrossURLPathState(initial, {
+    emit: true,
+    receive: false
+  });
+  let originalPushState;
+  let originalReplaceState;
+  const update = () => setState(window.location.pathname);
+  try {
+    const destroyRef = (0, import_core.inject)(import_core.DestroyRef, { optional: true });
+    if (destroyRef && typeof window !== "undefined") {
+      originalPushState = history.pushState;
+      originalReplaceState = history.replaceState;
+      const wrap = (fn) => (...args) => {
+        fn.apply(history, args);
+        window.dispatchEvent(new Event("locationchange"));
+      };
+      history.pushState = wrap(originalPushState);
+      history.replaceState = wrap(originalReplaceState);
+      window.addEventListener("locationchange", update);
+      window.addEventListener("popstate", update);
+      window.addEventListener("hashchange", update);
+      update();
+      destroyRef.onDestroy(() => {
+        window.removeEventListener("locationchange", update);
+        window.removeEventListener("popstate", update);
+        window.removeEventListener("hashchange", update);
+        if (originalPushState) history.pushState = originalPushState;
+        if (originalReplaceState) history.replaceState = originalReplaceState;
+      });
+    }
+  } catch {
+    console.warn(
+      "useCrossURLPathSetter called outside injection context; URL path synchronization may not be available."
+    );
+  }
+  return [state, setState];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useCrossURLPathSetter,
+  useCrossURLPathState
+});
+//# sourceMappingURL=useCrossURLPathState.cjs.map

package/dist/cjs/editor/useCrossURLPathState.cjs.map

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

package/dist/cjs/editor/useEditedContentRenderer.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 useEditedContentRenderer_exports = {};
+__export(useEditedContentRenderer_exports, {
+  EDITED_CONTENT_ACTIONS_TOKEN: () => EDITED_CONTENT_ACTIONS_TOKEN,
+  EditedContentRendererService: () => EditedContentRendererService,
+  useEditedContentRenderer: () => useEditedContentRenderer
+});
+module.exports = __toCommonJS(useEditedContentRenderer_exports);
+var import_core = require("@angular/core");
+const EDITED_CONTENT_ACTIONS_TOKEN = new import_core.InjectionToken("editedContentActions");
+@((0, import_core.Injectable)({
+  providedIn: "root"
+}))
+class EditedContentRendererService {
+  /**
+   * Mirrors the React hook one-for-one.
+   */
+  useEditedContentRenderer(dictionaryKey, keyPath, fallback) {
+    const editedContentContext = (0, import_core.inject)(EDITED_CONTENT_ACTIONS_TOKEN, {
+      optional: true
+    });
+    return (0, import_core.computed)(() => {
+      const edited = editedContentContext?.getEditedContentValue(
+        dictionaryKey,
+        keyPath
+      );
+      return edited ?? fallback;
+    });
+  }
+}
+const useEditedContentRenderer = (dictionaryKey, keyPath, fallback) => {
+  const service = (0, import_core.inject)(EditedContentRendererService);
+  return service.useEditedContentRenderer(dictionaryKey, keyPath, fallback);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EDITED_CONTENT_ACTIONS_TOKEN,
+  EditedContentRendererService,
+  useEditedContentRenderer
+});
+//# sourceMappingURL=useEditedContentRenderer.cjs.map

package/dist/cjs/editor/useEditedContentRenderer.cjs.map

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

package/dist/cjs/editor/useEditor.cjs

@@ -0,0 +1,46 @@
+"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 useEditor_exports = {};
+__export(useEditor_exports, {
+  useEditor: () => useEditor
+});
+module.exports = __toCommonJS(useEditor_exports);
+var import_configuration = require('./configuration.cjs');
+var import_createSharedComposable = require('./createSharedComposable.cjs');
+var import_dictionariesRecord = require('./dictionariesRecord.cjs');
+var import_editorEnabled = require('./editorEnabled.cjs');
+var import_editorLocale = require('./editorLocale.cjs');
+var import_focusDictionary = require('./focusDictionary.cjs');
+var import_useCrossURLPathState = require('./useCrossURLPathState.cjs');
+var import_useIframeClickInterceptor = require('./useIframeClickInterceptor.cjs');
+const useEditor = (0, import_createSharedComposable.createSharedComposable)(() => {
+  (0, import_configuration.useConfiguration)();
+  (0, import_editorEnabled.useEditorEnabled)();
+  (0, import_focusDictionary.useFocusDictionary)();
+  (0, import_useIframeClickInterceptor.useIframeClickMerger)();
+  (0, import_useCrossURLPathState.useCrossURLPathSetter)();
+  (0, import_editorLocale.useEditorLocale)();
+  (0, import_dictionariesRecord.useDictionariesRecord)();
+  (0, import_editorLocale.useEditorLocale)();
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEditor
+});
+//# sourceMappingURL=useEditor.cjs.map

package/dist/cjs/editor/useEditor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/editor/useEditor.ts"],"sourcesContent":["import { useConfiguration } from './configuration';\nimport { createSharedComposable } from './createSharedComposable';\nimport { useDictionariesRecord } from './dictionariesRecord';\nimport { useEditorEnabled } from './editorEnabled';\nimport { useEditorLocale } from './editorLocale';\nimport { useFocusDictionary } from './focusDictionary';\nimport { useCrossURLPathSetter } from './useCrossURLPathState';\nimport { useIframeClickMerger } from './useIframeClickInterceptor';\n\nexport const useEditor = createSharedComposable(() => {\n  useConfiguration();\n  useEditorEnabled();\n  useFocusDictionary();\n  useIframeClickMerger();\n  useCrossURLPathSetter();\n  useEditorLocale();\n  useDictionariesRecord();\n  useEditorLocale();\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,2BAAiC;AACjC,oCAAuC;AACvC,gCAAsC;AACtC,2BAAiC;AACjC,0BAAgC;AAChC,6BAAmC;AACnC,kCAAsC;AACtC,uCAAqC;AAE9B,MAAM,gBAAY,sDAAuB,MAAM;AACpD,6CAAiB;AACjB,6CAAiB;AACjB,iDAAmB;AACnB,6DAAqB;AACrB,yDAAsB;AACtB,2CAAgB;AAChB,uDAAsB;AACtB,2CAAgB;AAClB,CAAC;","names":[]}

package/dist/cjs/editor/useIframeClickInterceptor.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 useIframeClickInterceptor_exports = {};
+__export(useIframeClickInterceptor_exports, {
+  useIframeClickInterceptor: () => useIframeClickInterceptor,
+  useIframeClickMerger: () => useIframeClickMerger
+});
+module.exports = __toCommonJS(useIframeClickInterceptor_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');
+const useIframeClickInterceptor = (0, import_createSharedComposable.createSharedComposable)(() => {
+  const postMessage = (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    import_editor.MessageKey.INTLAYER_IFRAME_CLICKED
+  );
+  const handler = () => {
+    postMessage();
+  };
+  try {
+    const destroyRef = (0, import_core.inject)(import_core.DestroyRef, { optional: true });
+    if (destroyRef && typeof window !== "undefined") {
+      window.addEventListener("mousedown", handler);
+      destroyRef.onDestroy(
+        () => window.removeEventListener("mousedown", handler)
+      );
+    }
+  } catch {
+    console.warn(
+      "useIframeClickInterceptor called outside injection context; event listener setup may not be available."
+    );
+  }
+});
+const useIframeClickMerger = (0, import_createSharedComposable.createSharedComposable)(() => {
+  useIframeClickInterceptor();
+  (0, import_useCrossFrameMessageListener.useCrossFrameMessageListener)(
+    import_editor.MessageKey.INTLAYER_IFRAME_CLICKED,
+    import_editor.mergeIframeClick
+  );
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useIframeClickInterceptor,
+  useIframeClickMerger
+});
+//# sourceMappingURL=useIframeClickInterceptor.cjs.map

package/dist/cjs/editor/useIframeClickInterceptor.cjs.map

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

package/dist/cjs/getDictionary.cjs

@@ -18,10 +18,23 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var getDictionary_exports = {};
 __export(getDictionary_exports, {
-  getDictionary: () => import_getDictionary.getDictionary
+  getDictionary: () => getDictionary
 });
 module.exports = __toCommonJS(getDictionary_exports);
-var import_getDictionary = require('./client/getDictionary.cjs');
+var import_core = require("@intlayer/core");
+var import_plugins = require('./plugins.cjs');
+const getDictionary = (dictionary, locale, additionalPlugins) => {
+  const plugins = [
+    import_plugins.intlayerNodePlugins,
+    import_plugins.markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return (0, import_core.getDictionary)(
+    dictionary,
+    locale,
+    plugins
+  );
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getDictionary

package/dist/cjs/getDictionary.cjs.map

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

package/dist/cjs/getIntlayer.cjs

@@ -21,8 +21,15 @@ __export(getIntlayer_exports, {
   getIntlayer: () => getIntlayer
 });
 module.exports = __toCommonJS(getIntlayer_exports);
-const getIntlayer = (dictionary, locale, additionalPlugins) => {
-  return dictionary.content || dictionary;
+var import_core = require("@intlayer/core");
+var import_plugins = require('./plugins.cjs');
+const getIntlayer = (key, locale, additionalPlugins) => {
+  const plugins = [
+    import_plugins.intlayerNodePlugins,
+    import_plugins.markdownPlugin,
+    ...additionalPlugins ?? []
+  ];
+  return (0, import_core.getIntlayer)(key, locale, plugins);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/getIntlayer.cjs.map

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

package/dist/cjs/markdown/index.cjs

@@ -3,10 +3,6 @@ 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))
@@ -15,22 +11,13 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 markdown_exports = {};
-__export(markdown_exports, {
-  MarkdownModule: () => MarkdownModule,
-  renderMarkdown: () => renderMarkdown
-});
 module.exports = __toCommonJS(markdown_exports);
-const renderMarkdown = (content) => {
-  return content;
-};
-const MarkdownModule = {
-  renderMarkdown
-};
+__reExport(markdown_exports, require('./installIntlayerMarkdown.cjs'), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MarkdownModule,
-  renderMarkdown
+  ...require('./installIntlayerMarkdown.cjs')
 });
 //# sourceMappingURL=index.cjs.map

package/dist/cjs/markdown/index.cjs.map

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

package/dist/cjs/markdown/installIntlayerMarkdown.cjs

@@ -0,0 +1,66 @@
+"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 installIntlayerMarkdown_exports = {};
+__export(installIntlayerMarkdown_exports, {
+  INTLAYER_MARKDOWN_TOKEN: () => INTLAYER_MARKDOWN_TOKEN,
+  IntlayerMarkdownService: () => IntlayerMarkdownService,
+  createIntlayerMarkdownProvider: () => createIntlayerMarkdownProvider,
+  useMarkdown: () => useMarkdown
+});
+module.exports = __toCommonJS(installIntlayerMarkdown_exports);
+var import_core = require("@angular/core");
+const INTLAYER_MARKDOWN_TOKEN = new import_core.InjectionToken("intlayerMarkdown");
+const defaultMarkdownRenderer = (markdown) => markdown;
+const createIntlayerMarkdownProvider = (renderMarkdown = defaultMarkdownRenderer) => ({
+  provide: INTLAYER_MARKDOWN_TOKEN,
+  useValue: {
+    renderMarkdown
+  }
+});
+@((0, import_core.Injectable)({
+  providedIn: "root"
+}))
+class IntlayerMarkdownService {
+  markdownProvider = (0, import_core.inject)(INTLAYER_MARKDOWN_TOKEN, {
+    optional: true
+  });
+  renderMarkdown(markdown) {
+    if (!this.markdownProvider) {
+      return markdown;
+    }
+    return this.markdownProvider.renderMarkdown(markdown);
+  }
+}
+const useMarkdown = () => {
+  const markdownProvider = (0, import_core.inject)(INTLAYER_MARKDOWN_TOKEN, { optional: true });
+  if (!markdownProvider) {
+    return {
+      renderMarkdown: defaultMarkdownRenderer
+    };
+  }
+  return markdownProvider;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INTLAYER_MARKDOWN_TOKEN,
+  IntlayerMarkdownService,
+  createIntlayerMarkdownProvider,
+  useMarkdown
+});
+//# sourceMappingURL=installIntlayerMarkdown.cjs.map

package/dist/cjs/markdown/installIntlayerMarkdown.cjs.map

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