@argusoft/medplat-core 1.0.31 → 1.0.32

package/dist/index-mfoqII2U.js

@@ -0,0 +1,524 @@
+import d, { memo as S, forwardRef as m, useRef as g, useEffect as _ } from "react";
+function x() {
+  const e = {
+    resolve: null,
+    promise: null
+  };
+  return e.promise = new Promise((t) => {
+    e.resolve = t;
+  }), e;
+}
+function D(e) {
+  let t = null;
+  return (...n) => (t || (t = {
+    current: e(...n)
+  }), t.current);
+}
+const c = new Array(256).fill("").map((e, t) => ("0" + t.toString(16)).slice(-2));
+function M() {
+  const [e, t, n, r] = crypto.getRandomValues(new Uint32Array(4));
+  return "e" + c[e >> 0 & 255] + c[e >> 8 & 255] + c[e >> 16 & 255] + c[e >> 24 & 255] + c[t >> 0 & 255] + c[t >> 8 & 255] + c[t >> 16 & 255] + c[t >> 24 & 255] + c[n >> 0 & 255] + c[n >> 8 & 255] + c[n >> 16 & 255] + c[n >> 24 & 255] + c[r >> 0 & 255] + c[r >> 8 & 255] + c[r >> 16 & 255] + c[r >> 24 & 255];
+}
+function E(e) {
+  return !!e && /^\d+\.\d+\.\d+/.test(e);
+}
+function W(e) {
+  if (!E(e))
+    throw new Error(`Invalid semantic version: ${e || "<blank>"}.`);
+  const [t, n, r] = e.split(".");
+  return {
+    major: Number.parseInt(t, 10),
+    minor: Number.parseInt(n, 10),
+    patch: Number.parseInt(r, 10)
+  };
+}
+function y(e) {
+  return e ? ["nightly", "alpha", "internal", "nightly-", "staging"].some((t) => e.includes(t)) : !1;
+}
+function L(e) {
+  return E(e) || y(e);
+}
+function V(e, t) {
+  const n = e.extraPlugins || [];
+  return {
+    ...e,
+    extraPlugins: [
+      ...n,
+      ...t.filter((r) => !n.includes(r))
+    ]
+  };
+}
+function T(e) {
+  if (y(e))
+    return 3;
+  const { major: t } = W(e);
+  switch (!0) {
+    case t >= 44:
+      return 3;
+    case t >= 38:
+      return 2;
+    default:
+      return 1;
+  }
+}
+function k() {
+  const { CKEDITOR_VERSION: e, CKEDITOR: t } = window;
+  return L(e) ? {
+    source: t ? "cdn" : "npm",
+    version: e
+  } : null;
+}
+function K() {
+  const e = k();
+  return e ? T(e.version) : null;
+}
+function C(e, t) {
+  switch (t || (t = K() || void 0), t) {
+    case 1:
+    case 2:
+      return e === void 0;
+    case 3:
+      return e === "GPL";
+    default:
+      return !1;
+  }
+}
+function P(e, t) {
+  return function(r) {
+    C(r.config.get("licenseKey")) || r.on("collectUsageData", (i, { setUsageData: s }) => {
+      s(`integration.${e}`, t);
+    });
+  };
+}
+var O = Object.defineProperty, A = (e, t, n) => t in e ? O(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, u = (e, t, n) => A(e, typeof t != "symbol" ? t + "" : t, n);
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+const w = class v {
+  constructor(t, n) {
+    u(this, "_lifecycle"), u(this, "_element"), u(this, "_releaseLock", null), u(this, "_value", null), u(this, "_afterMountCallbacks", []), u(this, "_state", {
+      destroyedBeforeInitialization: !1,
+      mountingInProgress: null
+    }), u(this, "release", D(() => {
+      const { _releaseLock: r, _state: i, _element: s, _lifecycle: o } = this;
+      i.mountingInProgress ? i.mountingInProgress.then(() => o.unmount({
+        element: s,
+        // Mount result might be overridden by watchdog during restart so use instance variable.
+        mountResult: this.value
+      })).catch((a) => {
+        console.error("Semaphore unmounting error:", a);
+      }).then(r.resolve).then(() => {
+        this._value = null;
+      }) : (i.destroyedBeforeInitialization = !0, r.resolve());
+    })), this._element = t, this._lifecycle = n, this._lock();
+  }
+  /**
+   * Getter for {@link #_value}.
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Occasionally, the Watchdog restarts the editor instance, resulting in a new instance being assigned to the semaphore.
+   * In terms of race conditions, it's generally safer to simply override the semaphore value rather than recreating it
+   * with a different one.
+   */
+  unsafeSetValue(t) {
+    this._value = t, this._afterMountCallbacks.forEach((n) => n(t)), this._afterMountCallbacks = [];
+  }
+  /**
+   * This registers a callback that will be triggered after the editor has been successfully mounted.
+   *
+   * 	* If the editor is already mounted, the callback will be executed immediately.
+   *	* If the editor is in the process of mounting, the callback will be executed upon successful mounting.
+  * 	* If the editor is never mounted, the passed callback will not be executed.
+  * 	* If an exception is thrown within the callback, it will be re-thrown in the semaphore.
+  */
+  runAfterMount(t) {
+    const { _value: n, _afterMountCallbacks: r } = this;
+    n ? t(n) : r.push(t);
+  }
+  /**
+   * This method is used to inform other components that the {@link #_element} will be used by the editor,
+   * which is initialized by the {@link #_lifecycle} methods.
+   *
+   * 	* If an editor is already present on the provided element, the initialization of the current one
+   * 	  will be postponed until the previous one is destroyed.
+   *
+   * 	* If the element is empty and does not have an editor attached to it, the currently locked editor will
+   * 	  be mounted immediately.
+   *
+   * After the successful initialization of the editor and the assignment of the {@link #_value} member,
+   * the `onReady` lifecycle method is called.
+   *
+   * *Important note:*
+   *
+   * It’s really important to keep this method *sync*. If we make this method *async*, it won’t work well because
+   * it will cause problems when we’re trying to set up the {@link LifeCycleEditorElementSemaphore#_semaphores} map entries.
+   */
+  _lock() {
+    const { _semaphores: t } = v, { _state: n, _element: r, _lifecycle: i } = this, s = t.get(r) || Promise.resolve(null), o = x();
+    this._releaseLock = o;
+    const a = s.then(() => n.destroyedBeforeInitialization ? Promise.resolve(void 0) : (n.mountingInProgress = i.mount().then((l) => (l && this.unsafeSetValue(l), l)), n.mountingInProgress)).then(async (l) => {
+      l && i.afterMount && await i.afterMount({
+        element: r,
+        mountResult: l
+      });
+    }).then(() => o.promise).catch((l) => {
+      console.error("Semaphore mounting error:", l);
+    }).then(() => {
+      t.get(r) === a && t.delete(r);
+    });
+    t.set(r, a);
+  }
+};
+u(w, "_semaphores", /* @__PURE__ */ new Map());
+let U = w;
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+const z = "$__CKEditorReactContextMetadata";
+function N(e, t) {
+  return {
+    ...t,
+    [z]: e
+  };
+}
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+const B = d.createContext(null), F = (e) => !!e && typeof e == "object" && "status" in e && ["initializing", "initialized", "error"].includes(e.status), R = (e) => (t) => F(t) && t.status === e, p = R("initializing"), $ = (e) => R("initialized")(e) && e.watchdog.state === "ready";
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+const G = P(
+  "react",
+  {
+    version: "9.5.0",
+    frameworkVersion: d.version
+  }
+);
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+function H(e) {
+  return C(e.licenseKey) ? e : V(e, [
+    /**
+     * This part of the code is not executed in open-source implementations using a GPL key.
+     * It only runs when a specific license key is provided. If you are uncertain whether
+     * this applies to your installation, please contact our support team.
+     */
+    G
+  ]);
+}
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+const h = "Lock from React integration (@ckeditor/ckeditor5-react)";
+class q extends d.Component {
+  constructor(t) {
+    super(t), u(this, "domContainer", d.createRef()), u(this, "editorSemaphore", null), this._checkVersion();
+  }
+  /**
+   * Checks if the CKEditor version used in the application is compatible with the component.
+   */
+  _checkVersion() {
+    const { CKEDITOR_VERSION: t } = window;
+    if (!t)
+      return console.warn('Cannot find the "CKEDITOR_VERSION" in the "window" scope.');
+    const [n] = t.split(".").map(Number);
+    n >= 42 || t.startsWith("0.0.0") || console.warn("The <CKEditor> component requires using CKEditor 5 in version 42+ or nightly build.");
+  }
+  get _semaphoreValue() {
+    const { editorSemaphore: t } = this;
+    return t ? t.value : null;
+  }
+  /**
+   * An watchdog instance.
+   */
+  get watchdog() {
+    const { _semaphoreValue: t } = this;
+    return t ? t.watchdog : null;
+  }
+  /**
+   * An editor instance.
+   */
+  get editor() {
+    const { _semaphoreValue: t } = this;
+    return t ? t.instance : null;
+  }
+  /**
+   * The CKEditor component should not be updated by React itself.
+   * However, if the component identifier changes, the whole structure should be created once again.
+   */
+  shouldComponentUpdate(t) {
+    const { props: n, editorSemaphore: r } = this;
+    return t.id !== n.id || t.disableWatchdog !== n.disableWatchdog ? !0 : (r && (r.runAfterMount(({ instance: i }) => {
+      this._shouldUpdateEditorData(n, t, i) && i.data.set(t.data);
+    }), "disabled" in t && r.runAfterMount(({ instance: i }) => {
+      t.disabled ? i.enableReadOnlyMode(h) : i.disableReadOnlyMode(h);
+    })), !1);
+  }
+  /**
+   * Initialize the editor when the component is mounted.
+   */
+  componentDidMount() {
+    p(this.context) || this._initLifeCycleSemaphore();
+  }
+  /**
+   * Re-render the entire component once again. The old editor will be destroyed and the new one will be created.
+   */
+  componentDidUpdate() {
+    p(this.context) || this._initLifeCycleSemaphore();
+  }
+  /**
+   * Destroy the editor before unmounting the component.
+   */
+  componentWillUnmount() {
+    this._unlockLifeCycleSemaphore();
+  }
+  /**
+   * Async destroy attached editor and unlock element semaphore.
+   */
+  _unlockLifeCycleSemaphore() {
+    this.editorSemaphore && (this.editorSemaphore.release(), this.editorSemaphore = null);
+  }
+  /**
+   * Unlocks previous editor semaphore and creates new one..
+   */
+  _initLifeCycleSemaphore() {
+    this._unlockLifeCycleSemaphore(), this.editorSemaphore = new U(this.domContainer.current, {
+      mount: async () => this._initializeEditor(),
+      afterMount: ({ mountResult: t }) => {
+        const { onReady: n } = this.props;
+        n && this.domContainer.current !== null && n(t.instance);
+      },
+      unmount: async ({ element: t, mountResult: n }) => {
+        const { onAfterDestroy: r } = this.props;
+        try {
+          await this._destroyEditor(n), t.innerHTML = "";
+        } finally {
+          r && r(n.instance);
+        }
+      }
+    });
+  }
+  /**
+   * Render a <div> element which will be replaced by CKEditor.
+   */
+  render() {
+    return /* @__PURE__ */ d.createElement("div", { ref: this.domContainer });
+  }
+  /**
+   * Initializes the editor by creating a proper watchdog and initializing it with the editor's configuration.
+   */
+  async _initializeEditor() {
+    if (this.props.disableWatchdog)
+      return {
+        instance: await this._createEditor(this.domContainer.current, this._getConfig()),
+        watchdog: null
+      };
+    const t = $(this.context) ? new X(this.context.watchdog) : new this.props.editor.EditorWatchdog(this.props.editor, this.props.watchdogConfig), n = {
+      current: 0
+    };
+    return t.setCreator(async (r, i) => {
+      var s;
+      const { editorSemaphore: o } = this, { onAfterDestroy: a } = this.props;
+      n.current > 0 && a && ((s = o == null ? void 0 : o.value) != null && s.instance) && a(o.value.instance);
+      const l = await this._createEditor(r, i);
+      return o && n.current > 0 && (o.unsafeSetValue({
+        instance: l,
+        watchdog: t
+      }), setTimeout(() => {
+        this.props.onReady && this.props.onReady(t.editor);
+      })), n.current++, l;
+    }), t.on("error", (r, { error: i, causesRestart: s }) => {
+      (this.props.onError || console.error)(i, { phase: "runtime", willEditorRestart: s });
+    }), await t.create(this.domContainer.current, this._getConfig()).catch((r) => {
+      (this.props.onError || console.error)(r, { phase: "initialization", willEditorRestart: !1 });
+    }), {
+      watchdog: t,
+      instance: t.editor
+    };
+  }
+  /**
+   * Creates an editor from the element and configuration.
+   *
+   * @param element The source element.
+   * @param config CKEditor 5 editor configuration.
+   */
+  _createEditor(t, n) {
+    const { contextItemMetadata: r } = this.props;
+    return r && (n = N(r, n)), this.props.editor.create(
+      t,
+      H(n)
+    ).then((i) => {
+      if ("disabled" in this.props) {
+        /* istanbul ignore else -- @preserve */
+        this.props.disabled && i.enableReadOnlyMode(h);
+      }
+      const s = i.model.document, o = i.editing.view.document;
+      return s.on("change:data", (a) => {
+        /* istanbul ignore else -- @preserve */
+        this.props.onChange && this.props.onChange(a, i);
+      }), o.on("focus", (a) => {
+        /* istanbul ignore else -- @preserve */
+        this.props.onFocus && this.props.onFocus(a, i);
+      }), o.on("blur", (a) => {
+        /* istanbul ignore else -- @preserve */
+        this.props.onBlur && this.props.onBlur(a, i);
+      }), i;
+    });
+  }
+  /**
+   * Destroys the editor by destroying the watchdog.
+   */
+  async _destroyEditor(t) {
+    const { watchdog: n, instance: r } = t;
+    return new Promise((i, s) => {
+      /* istanbul ignore next -- @preserve */
+      setTimeout(async () => {
+        try {
+          if (n)
+            return await n.destroy(), i();
+          if (r)
+            return await r.destroy(), i();
+          i();
+        } catch (o) {
+          console.error(o), s(o);
+        }
+      });
+    });
+  }
+  /**
+   * Returns true when the editor should be updated.
+   *
+   * @param prevProps Previous react's properties.
+   * @param nextProps React's properties.
+   * @param editor Current editor instance.
+   */
+  _shouldUpdateEditorData(t, n, r) {
+    return !(t.data === n.data || r.data.get() === n.data);
+  }
+  /**
+   * Returns the editor configuration.
+   */
+  _getConfig() {
+    const t = this.props.config || {};
+    return this.props.data && t.initialData && console.warn(
+      "Editor data should be provided either using `config.initialData` or `content` property. The config value takes precedence over `content` property and will be used when both are specified."
+    ), {
+      ...t,
+      initialData: t.initialData || this.props.data || ""
+    };
+  }
+}
+u(q, "contextType", B);
+class X {
+  /**
+   * @param contextWatchdog The context watchdog instance that will be wrapped into editor watchdog API.
+   */
+  constructor(t) {
+    u(this, "_contextWatchdog"), u(this, "_id"), u(this, "_creator"), this._contextWatchdog = t, this._id = M();
+  }
+  /**
+   *  @param creator A watchdog's editor creator function.
+   */
+  setCreator(t) {
+    this._creator = t;
+  }
+  /**
+   * Adds an editor configuration to the context watchdog registry. Creates an instance of it.
+   *
+   * @param sourceElementOrData A source element or data for the new editor.
+   * @param config CKEditor 5 editor config.
+   */
+  create(t, n) {
+    return this._contextWatchdog.add({
+      sourceElementOrData: t,
+      config: n,
+      creator: this._creator,
+      id: this._id,
+      type: "editor"
+    });
+  }
+  /**
+   * Creates a listener that is attached to context watchdog's item and run when the context watchdog fires.
+   * Currently works only for the `error` event.
+   */
+  on(t, n) {
+    this._contextWatchdog.on("itemError", (r, { itemId: i, error: s }) => {
+      i === this._id && n(null, { error: s, causesRestart: void 0 });
+    });
+  }
+  destroy() {
+    return this._contextWatchdog.state === "ready" ? this._contextWatchdog.remove(this._id) : Promise.resolve();
+  }
+  /**
+   * An editor instance.
+   */
+  get editor() {
+    return this._contextWatchdog.getItem(this._id);
+  }
+}
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+function b(...e) {
+  return (t) => {
+    e.forEach((n) => {
+      typeof n == "function" ? n(t) : n != null && (n.current = t);
+    });
+  };
+}
+const Y = S(m(({ id: e, semaphore: t, rootName: n }, r) => {
+  const i = g(null);
+  return _(() => {
+    let s, o;
+    return t.runAfterMount(({ instance: a }) => {
+      if (!i.current)
+        return;
+      o = a;
+      const { ui: l, model: I } = o, f = I.document.getRoot(n);
+      f && o.ui.getEditableElement(n) && o.detachEditable(f), s = l.view.createEditable(n, i.current), l.addEditable(s), a.editing.view.forceRender();
+    }), () => {
+      if (o && o.state !== "destroyed" && i.current) {
+        const a = o.model.document.getRoot(n);
+        /* istanbul ignore else -- @preserve */
+        a && o.detachEditable(a);
+      }
+    };
+  }, [t.revision]), /* @__PURE__ */ d.createElement(
+    "div",
+    {
+      key: t.revision,
+      id: e,
+      ref: b(r, i)
+    }
+  );
+}));
+Y.displayName = "EditorEditable";
+const J = m(({ editor: e }, t) => {
+  const n = g(null);
+  return _(() => {
+    const r = n.current;
+    if (!e || !r)
+      return;
+    const i = e.ui.view.toolbar.element;
+    return r.appendChild(i), () => {
+      r.contains(i) && r.removeChild(i);
+    };
+  }, [e && e.id]), /* @__PURE__ */ d.createElement("div", { ref: b(n, t) });
+});
+J.displayName = "EditorToolbarWrapper";
+export {
+  q as C
+};
+//# sourceMappingURL=index-mfoqII2U.js.map