solid-intlayer 5.5.9 → 5.5.11

package/dist/esm/editor/IntlayerEditorProvider.mjs

@@ -0,0 +1,64 @@
+import { m as p } from "../../web-BFg6-54-.mjs";
+import { IntlayerEventListener as a } from "@intlayer/api";
+import m from "@intlayer/config/built";
+import { createComponent as i, onMount as c, onCleanup as l } from "solid-js";
+import "@intlayer/editor";
+import { useChangedContentActions as f } from "./contexts/ChangedContentContext.mjs";
+import "./contexts/ConfigurationContext.mjs";
+import "./contexts/DictionariesRecordContext.mjs";
+import "./contexts/EditedContentContext.mjs";
+import { useEditorEnabled as u } from "./contexts/EditorEnabledContext.mjs";
+import { EditorProvider as d } from "./contexts/EditorProvider.mjs";
+import "./contexts/FocusDictionaryContext.mjs";
+import "./contexts/CommunicatorContext.mjs";
+import { useCrossURLPathSetter as g } from "./contexts/useCrossURLPathState.mjs";
+import { useIframeClickInterceptor as w } from "./contexts/useIframeClickInterceptor.mjs";
+const I = () => (g(), w(), []), {
+  editor: e
+} = m, L = () => {
+  const {
+    enabled: n
+  } = u(), r = f();
+  return c(() => {
+    if (!e.hotReload || !e.clientId || !e.clientSecret) return;
+    const o = new a();
+    try {
+      o.initialize().then(() => {
+        o.onDictionaryChange = (t) => r == null ? void 0 : r.setChangedContent(t.key, t.content);
+      });
+    } catch (t) {
+      console.error("Error initializing IntlayerEventListener:", t);
+    }
+    l(() => o.cleanup());
+  }), n() ? i(I, {}) : [];
+}, D = (n) => i(d, {
+  postMessage: (r) => {
+    var t, s;
+    typeof window > "u" || !(window.self !== window.top) || (e.applicationURL.length > 0 && (window == null || window.postMessage(
+      r,
+      // Use to restrict the origin of the editor for security reasons.
+      // Correspond to the current application URL to synchronize the locales states.
+      e.applicationURL
+    )), e.editorURL.length > 0 && ((t = window.parent) == null || t.postMessage(
+      r,
+      // Use to restrict the origin of the editor for security reasons.
+      // Correspond to the editor URL to synchronize the locales states.
+      e.editorURL
+    )), e.cmsURL.length > 0 && ((s = window.parent) == null || s.postMessage(
+      r,
+      // Use to restrict the origin of the CMS for security reasons.
+      // Correspond to the CMS URL.
+      e.cmsURL
+    )));
+  },
+  get allowedOrigins() {
+    return [e == null ? void 0 : e.editorURL, e == null ? void 0 : e.cmsURL, e == null ? void 0 : e.applicationURL];
+  },
+  configuration: m,
+  get children() {
+    return [i(L, {}), p(() => n.children)];
+  }
+});
+export {
+  D as IntlayerEditorProvider
+};

package/dist/esm/editor/contexts/ChangedContentContext.mjs

@@ -0,0 +1,39 @@
+import { createContext as r, createSignal as i, createComponent as C, useContext as d } from "solid-js";
+const a = r(void 0), s = r(void 0), x = (n) => {
+  const [o, t] = i({}), g = (c, h) => {
+    t((e) => ({
+      ...e,
+      [c]: {
+        ...e == null ? void 0 : e[c],
+        content: h
+      }
+    }));
+  };
+  return C(a.Provider, {
+    value: {
+      changedContent: o
+    },
+    get children() {
+      return C(s.Provider, {
+        value: {
+          setChangedContent: g
+        },
+        get children() {
+          return n.children;
+        }
+      });
+    }
+  });
+}, u = () => d(s), m = () => {
+  var t;
+  const n = d(a), o = u();
+  return {
+    changedContent: (t = n == null ? void 0 : n.changedContent) == null ? void 0 : t.call(n),
+    ...o
+  };
+};
+export {
+  x as ChangedContentProvider,
+  m as useChangedContent,
+  u as useChangedContentActions
+};

package/dist/esm/editor/contexts/CommunicatorContext.mjs

@@ -0,0 +1,30 @@
+import s from "@intlayer/config/built";
+import { createContext as c, useContext as a, createMemo as x, createComponent as i } from "solid-js";
+const u = () => "xxxx-xxxx-4xxx-yxxx".replace(/[xy]/g, function(n) {
+  const t = Math.random() * 16 | 0;
+  return (n == "x" ? t : t & 3 | 8).toString(16);
+}), {
+  editor: e
+} = s, r = c({
+  postMessage: () => null,
+  allowedOrigins: [e == null ? void 0 : e.applicationURL, e == null ? void 0 : e.editorURL, e == null ? void 0 : e.cmsURL],
+  senderId: ""
+}), g = (n) => {
+  const t = u(), o = x(() => ({
+    postMessage: n.postMessage,
+    allowedOrigins: n.allowedOrigins,
+    senderId: t
+  }));
+  return i(r.Provider, {
+    get value() {
+      return o();
+    },
+    get children() {
+      return n.children;
+    }
+  });
+}, d = () => a(r);
+export {
+  g as CommunicatorProvider,
+  d as useCommunicator
+};

package/dist/esm/editor/contexts/ConfigurationContext.mjs

@@ -0,0 +1,19 @@
+import { MessageKey as o } from "@intlayer/editor";
+import { createContext as r, createComponent as n, useContext as i } from "solid-js";
+import { useCrossFrameState as a } from "./useCrossFrameState.mjs";
+const t = r(void 0), C = () => a(o.INTLAYER_CONFIGURATION, void 0, {
+  receive: !1,
+  emit: !0
+}), f = (e) => n(t.Provider, {
+  get value() {
+    return e.configuration;
+  },
+  get children() {
+    return e.children;
+  }
+}), m = () => i(t);
+export {
+  f as ConfigurationProvider,
+  m as useConfiguration,
+  C as useConfigurationState
+};

package/dist/esm/editor/contexts/DictionariesRecordContext.mjs

@@ -0,0 +1,44 @@
+import { MessageKey as C } from "@intlayer/editor";
+import { createContext as c, useContext as s, createMemo as i, createComponent as n } from "solid-js";
+import { useCrossFrameState as m } from "./useCrossFrameState.mjs";
+const a = c(void 0), d = c(void 0), g = (t) => {
+  const [e, o] = m(C.INTLAYER_LOCALE_DICTIONARIES_CHANGED, void 0), u = i(() => ({
+    localeDictionaries: e() ?? {}
+  })), l = i(() => ({
+    setLocaleDictionaries: o,
+    setLocaleDictionary: (r) => {
+      o((D) => ({
+        ...D,
+        [r.key]: r
+      }));
+    }
+  }));
+  return n(a.Provider, {
+    get value() {
+      return u();
+    },
+    get children() {
+      return n(d.Provider, {
+        get value() {
+          return l();
+        },
+        get children() {
+          return t.children;
+        }
+      });
+    }
+  });
+}, v = () => s(d), h = () => {
+  const t = v(), e = s(a);
+  if (!e)
+    throw new Error("useDictionariesRecordStates must be used within a DictionariesRecordProvider");
+  return {
+    ...e,
+    ...t
+  };
+};
+export {
+  g as DictionariesRecordProvider,
+  h as useDictionariesRecord,
+  v as useDictionariesRecordActions
+};

package/dist/esm/editor/contexts/EditedContentContext.mjs

@@ -0,0 +1,147 @@
+import { getContentNodeByKeyPath as D, renameContentNodeByKeyPath as Y, editDictionaryByKeyPath as j } from "@intlayer/core";
+import { MessageKey as N } from "@intlayer/editor";
+import { createContext as _, useContext as x, createComponent as T } from "solid-js";
+import { useDictionariesRecord as M } from "./DictionariesRecordContext.mjs";
+import { useCrossFrameMessageListener as A } from "./useCrossFrameMessageListener.mjs";
+import { useCrossFrameState as W } from "./useCrossFrameState.mjs";
+const P = _(void 0), X = (r) => A(`${N.INTLAYER_EDITED_CONTENT_CHANGED}/post`, r), Z = (r) => A(`${N.INTLAYER_EDITED_CONTENT_CHANGED}/get`, r), I = _(void 0), K = (r) => {
+  const {
+    localeDictionaries: E
+  } = M(), [g, c] = W(N.INTLAYER_EDITED_CONTENT_CHANGED), w = (t) => {
+    if (typeof t == "function")
+      c((e) => {
+        const n = e == null ? void 0 : e[Object.keys(e || {})[0]], o = t(n);
+        return {
+          ...e,
+          [o.key]: o
+        };
+      });
+    else {
+      const e = t;
+      c((n) => ({
+        ...n,
+        [e.key]: e
+      }));
+    }
+  }, S = (t, e) => {
+    c((n) => ({
+      ...n,
+      [t]: {
+        ...n == null ? void 0 : n[t],
+        content: e
+      }
+    }));
+  }, F = (t, e, n = [], o = !0) => {
+    c((s) => {
+      var l, m;
+      const i = (l = E[t]) == null ? void 0 : l.content, C = structuredClone(((m = s == null ? void 0 : s[t]) == null ? void 0 : m.content) ?? i);
+      let d = n;
+      if (!o) {
+        let u = 0;
+        const H = n.slice(0, -1), f = n[n.length - 1];
+        let h = f.key;
+        for (; typeof D(C, d) < "u"; )
+          u++, h = u === 0 ? f.key : `${f.key} (${u})`, d = [...H, {
+            ...f,
+            key: h
+          }];
+      }
+      const a = j(C, d, e);
+      return {
+        ...s,
+        [t]: {
+          ...s == null ? void 0 : s[t],
+          content: a
+        }
+      };
+    });
+  }, G = (t, e, n = []) => {
+    c((o) => {
+      var d, a;
+      const s = (d = E[t]) == null ? void 0 : d.content, i = structuredClone(((a = o == null ? void 0 : o[t]) == null ? void 0 : a.content) ?? s), C = Y(i, e, n);
+      return {
+        ...o,
+        [t]: {
+          ...o == null ? void 0 : o[t],
+          content: C
+        }
+      };
+    });
+  }, L = (t, e) => {
+    c((n) => {
+      var a, l, m;
+      const o = (a = E[t]) == null ? void 0 : a.content, s = structuredClone(((l = n == null ? void 0 : n[t]) == null ? void 0 : l.content) ?? o), i = structuredClone(s), C = e.slice(0, -1), d = (m = e[e.length - 1]) == null ? void 0 : m.key;
+      if (d) {
+        const u = D(i, C);
+        u && typeof u == "object" && d in u && delete u[d];
+      }
+      return {
+        ...n,
+        [t]: {
+          ...n == null ? void 0 : n[t],
+          content: i
+        }
+      };
+    });
+  }, O = (t) => {
+    c((e) => {
+      const n = {
+        ...e
+      };
+      return delete n[t], n;
+    });
+  }, R = (t) => {
+    c((e) => ({
+      ...e,
+      [t]: {
+        ...e == null ? void 0 : e[t],
+        content: {}
+      }
+    }));
+  }, $ = () => {
+    c({});
+  }, b = (t, e) => {
+    var s, i, C;
+    const n = (s = E[t]) == null ? void 0 : s.content, o = ((C = (i = g()) == null ? void 0 : i[t]) == null ? void 0 : C.content) ?? n;
+    return D(o, e);
+  }, k = {
+    editedContent: g()
+  }, B = {
+    setEditedContentState: c,
+    setEditedDictionary: w,
+    setEditedContent: S,
+    addEditedContent: F,
+    renameEditedContent: G,
+    removeEditedContent: L,
+    restoreEditedContent: O,
+    clearEditedDictionaryContent: R,
+    clearEditedContent: $,
+    getEditedContentValue: b
+  };
+  return T(P.Provider, {
+    value: k,
+    get children() {
+      return T(I.Provider, {
+        value: B,
+        get children() {
+          return r.children;
+        }
+      });
+    }
+  });
+}, V = () => x(I), p = () => {
+  const r = V(), E = x(P);
+  if (!E)
+    throw new Error("useEditedContent must be used within a EditedContentProvider");
+  return {
+    ...E,
+    ...r
+  };
+};
+export {
+  K as EditedContentProvider,
+  p as useEditedContent,
+  V as useEditedContentActions,
+  Z as useGetEditedContentState,
+  X as usePostEditedContentState
+};

package/dist/esm/editor/contexts/EditorEnabledContext.mjs

@@ -0,0 +1,27 @@
+import { MessageKey as t } from "@intlayer/editor";
+import { createContext as n, useContext as E, createComponent as a } from "solid-js";
+import { useCrossFrameMessageListener as r } from "./useCrossFrameMessageListener.mjs";
+import { useCrossFrameState as d } from "./useCrossFrameState.mjs";
+const o = n({
+  enabled: () => !1
+}), i = (e) => d(t.INTLAYER_EDITOR_ENABLED, !1, e), b = (e) => r(`${t.INTLAYER_EDITOR_ENABLED}/post`, e), f = (e) => r(`${t.INTLAYER_EDITOR_ENABLED}/get`, e), p = (e) => {
+  const [s] = i({
+    emit: !1,
+    receive: !0
+  });
+  return a(o.Provider, {
+    value: {
+      enabled: s
+    },
+    get children() {
+      return e.children;
+    }
+  });
+}, L = () => E(o);
+export {
+  p as EditorEnabledProvider,
+  L as useEditorEnabled,
+  i as useEditorEnabledState,
+  f as useGetEditorEnabledState,
+  b as usePostEditorEnabledState
+};

package/dist/esm/editor/contexts/EditorProvider.mjs

@@ -0,0 +1,85 @@
+import { m as o } from "../../../web-BFg6-54-.mjs";
+import { createComponent as r, createSignal as d, createEffect as i } from "solid-js";
+import { ChangedContentProvider as c } from "./ChangedContentContext.mjs";
+import { CommunicatorProvider as a } from "./CommunicatorContext.mjs";
+import { ConfigurationProvider as l } from "./ConfigurationContext.mjs";
+import { DictionariesRecordProvider as m } from "./DictionariesRecordContext.mjs";
+import { useGetEditedContentState as u, EditedContentProvider as g } from "./EditedContentContext.mjs";
+import { EditorEnabledProvider as f, useGetEditorEnabledState as s, useEditorEnabled as h } from "./EditorEnabledContext.mjs";
+import { FocusDictionaryProvider as E } from "./FocusDictionaryContext.mjs";
+const b = (e) => {
+  const t = u();
+  return i(() => {
+    t();
+  }), r(m, {
+    get children() {
+      return r(g, {
+        get children() {
+          return r(E, {
+            get children() {
+              return e.children;
+            }
+          });
+        }
+      });
+    }
+  });
+}, C = (e) => {
+  const t = s(), {
+    enabled: n
+  } = h();
+  return i(() => {
+    n() || t();
+  }), o(() => n() ? e.children : e.fallback);
+}, v = (e) => {
+  const [t, n] = d(!1);
+  return i(() => {
+    n(window.self !== window.top);
+  }), o(() => t() ? e.children : e.fallback);
+}, M = (e) => r(c, {
+  get children() {
+    return r(f, {
+      get children() {
+        return r(l, {
+          get configuration() {
+            return e.configuration;
+          },
+          get children() {
+            return r(v, {
+              get fallback() {
+                return e.children;
+              },
+              get children() {
+                return r(a, {
+                  get postMessage() {
+                    return e.postMessage;
+                  },
+                  get allowedOrigins() {
+                    return e.allowedOrigins;
+                  },
+                  get children() {
+                    return r(C, {
+                      get fallback() {
+                        return e.children;
+                      },
+                      get children() {
+                        return r(b, {
+                          get children() {
+                            return e.children;
+                          }
+                        });
+                      }
+                    });
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+});
+export {
+  M as EditorProvider
+};

package/dist/esm/editor/contexts/FocusDictionaryContext.mjs

@@ -0,0 +1,47 @@
+import { MessageKey as C } from "@intlayer/editor";
+import { createContext as i, createComponent as r, useContext as s } from "solid-js";
+import { useCrossFrameState as F } from "./useCrossFrameState.mjs";
+const c = i(void 0), u = i(void 0), f = (t) => {
+  const [o, n] = F(C.INTLAYER_FOCUSED_CONTENT_CHANGED, null), a = (d) => {
+    n((e) => e && {
+      ...e,
+      keyPath: d
+    });
+  };
+  return r(c.Provider, {
+    get value() {
+      return {
+        focusedContent: o()
+      };
+    },
+    get children() {
+      return r(u.Provider, {
+        value: {
+          setFocusedContent: n,
+          setFocusedContentKeyPath: a
+        },
+        get children() {
+          return t.children;
+        }
+      });
+    }
+  });
+}, y = () => {
+  const t = s(u);
+  if (t === void 0)
+    throw new Error("useFocusDictionaryActions must be used within a FocusDictionaryProvider");
+  return t;
+}, h = () => {
+  const t = y(), o = s(c);
+  if (o === void 0)
+    throw new Error("useFocusDictionaryState must be used within a FocusDictionaryProvider");
+  return {
+    ...o,
+    ...t
+  };
+};
+export {
+  f as FocusDictionaryProvider,
+  h as useFocusDictionary,
+  y as useFocusDictionaryActions
+};

package/dist/esm/editor/contexts/index.mjs

@@ -0,0 +1,43 @@
+export * from "@intlayer/editor";
+import { ChangedContentProvider as r, useChangedContent as i, useChangedContentActions as s } from "./ChangedContentContext.mjs";
+import { ConfigurationProvider as d, useConfiguration as a, useConfigurationState as u } from "./ConfigurationContext.mjs";
+import { DictionariesRecordProvider as c, useDictionariesRecord as f, useDictionariesRecordActions as m } from "./DictionariesRecordContext.mjs";
+import { EditedContentProvider as p, useEditedContent as x, useEditedContentActions as P, useGetEditedContentState as S, usePostEditedContentState as g } from "./EditedContentContext.mjs";
+import { EditorEnabledProvider as v, useEditorEnabled as D, useEditorEnabledState as b, useGetEditorEnabledState as h, usePostEditorEnabledState as F } from "./EditorEnabledContext.mjs";
+import { EditorProvider as A } from "./EditorProvider.mjs";
+import { FocusDictionaryProvider as I, useFocusDictionary as L, useFocusDictionaryActions as k } from "./FocusDictionaryContext.mjs";
+import { useCrossFrameMessageListener as M } from "./useCrossFrameMessageListener.mjs";
+import { useCrossFrameState as j } from "./useCrossFrameState.mjs";
+import { useCrossURLPathSetter as w, useCrossURLPathState as z } from "./useCrossURLPathState.mjs";
+import { useIframeClickInterceptor as H, useIframeClickMerger as J } from "./useIframeClickInterceptor.mjs";
+export {
+  r as ChangedContentProvider,
+  d as ConfigurationProvider,
+  c as DictionariesRecordProvider,
+  p as EditedContentProvider,
+  v as EditorEnabledProvider,
+  A as EditorProvider,
+  I as FocusDictionaryProvider,
+  i as useChangedContent,
+  s as useChangedContentActions,
+  a as useConfiguration,
+  u as useConfigurationState,
+  M as useCrossFrameMessageListener,
+  j as useCrossFrameState,
+  w as useCrossURLPathSetter,
+  z as useCrossURLPathState,
+  f as useDictionariesRecord,
+  m as useDictionariesRecordActions,
+  x as useEditedContent,
+  P as useEditedContentActions,
+  D as useEditorEnabled,
+  b as useEditorEnabledState,
+  L as useFocusDictionary,
+  k as useFocusDictionaryActions,
+  S as useGetEditedContentState,
+  h as useGetEditorEnabledState,
+  H as useIframeClickInterceptor,
+  J as useIframeClickMerger,
+  g as usePostEditedContentState,
+  F as usePostEditorEnabledState
+};

package/dist/esm/editor/contexts/useCrossFrameMessageListener.mjs

@@ -0,0 +1,35 @@
+import { compareUrls as c } from "@intlayer/editor";
+import { onMount as f, onCleanup as M } from "solid-js";
+import { useCommunicator as g } from "./CommunicatorContext.mjs";
+const I = (r, o, C) => {
+  const t = g();
+  if (!t)
+    throw new Error("useCrossFrameMessageListener must be used within a CommunicatorProvider");
+  const {
+    allowedOrigins: e,
+    postMessage: m,
+    senderId: n
+  } = t;
+  return f(() => {
+    if (o) {
+      const s = (a) => {
+        const {
+          type: i,
+          data: p,
+          senderId: d
+        } = a.data;
+        i === r && d !== n && (typeof e > "u" || e != null && e.some((u) => c(u, a.origin)) || e != null && e.includes("*")) && o(p);
+      };
+      window.addEventListener("message", s), M(() => window.removeEventListener("message", s));
+    }
+  }), (s) => {
+    m({
+      type: r,
+      data: s,
+      senderId: n
+    });
+  };
+};
+export {
+  I as useCrossFrameMessageListener
+};

package/dist/esm/editor/contexts/useCrossFrameState.mjs

@@ -0,0 +1,57 @@
+import { createSignal as $, createEffect as S } from "solid-js";
+import { useCommunicator as C } from "./CommunicatorContext.mjs";
+import { useCrossFrameMessageListener as a } from "./useCrossFrameMessageListener.mjs";
+const w = (e, s, m) => {
+  const {
+    postMessage: t,
+    senderId: n
+  } = C(), {
+    emit: f,
+    receive: c
+  } = m ?? {
+    emit: !0,
+    receive: !0
+  }, [r, u] = $(typeof s == "function" ? s() : s), d = () => {
+    typeof t == "function" && t({
+      type: `${e}/post`,
+      data: r(),
+      senderId: n
+    });
+  }, y = (o) => {
+    u((p) => {
+      const i = typeof o == "function" ? o(p) : o;
+      return f && typeof t == "function" && typeof i < "u" && t({
+        type: `${e}/post`,
+        data: i,
+        senderId: n
+      }), i;
+    });
+  };
+  a(
+    `${e}/post`,
+    // Only activate the state listener if the `receive` option is true
+    c ? (o) => {
+      u(() => o);
+    } : void 0
+  );
+  const g = (o, p) => {
+    f && typeof t == "function" && p !== n && (typeof r() > "u" || t({
+      type: `${e}/post`,
+      data: r(),
+      senderId: n
+    }));
+  };
+  return a(
+    `${e}/get`,
+    // Only activate the state listener if the `emit` option is true
+    f ? g : void 0
+  ), S(() => {
+    c && typeof t == "function" && typeof r() > "u" && t({
+      type: `${e}/get`,
+      senderId: n
+    });
+  }), [r, y, d];
+};
+export {
+  w as useCrossFrameState
+};

package/dist/esm/editor/contexts/useCrossURLPathState.mjs

@@ -0,0 +1,25 @@
+import { MessageKey as h } from "@intlayer/editor";
+import { onMount as d, onCleanup as p } from "solid-js";
+import { useCrossFrameState as w } from "./useCrossFrameState.mjs";
+const v = (n, e) => w(h.INTLAYER_URL_CHANGE, n, e), E = (n) => {
+  const e = v(n, {
+    emit: !0,
+    receive: !1
+  }), [l, i] = e;
+  return d(() => {
+    const o = history.pushState, a = history.replaceState, s = (r) => function(...c) {
+      r.apply(this, c), window.dispatchEvent(new Event("locationchange"));
+    };
+    history.pushState = s(o), history.replaceState = s(a);
+    const t = () => {
+      i(window.location.pathname);
+    };
+    window.addEventListener("locationchange", t), window.addEventListener("popstate", t), window.addEventListener("hashchange", t), window.addEventListener("load", t), t(), p(() => {
+      window.removeEventListener("locationchange", t), window.removeEventListener("popstate", t), window.removeEventListener("hashchange", t), window.removeEventListener("load", t), history.pushState = o, history.replaceState = a;
+    });
+  }), e;
+};
+export {
+  E as useCrossURLPathSetter,
+  v as useCrossURLPathState
+};

package/dist/esm/editor/contexts/useIframeClickInterceptor.mjs

@@ -0,0 +1,18 @@
+import { MessageKey as o, mergeIframeClick as t } from "@intlayer/editor";
+import { onMount as s, onCleanup as m } from "solid-js";
+import { useCrossFrameMessageListener as n } from "./useCrossFrameMessageListener.mjs";
+const a = () => {
+  const r = n(o.INTLAYER_IFRAME_CLICKED);
+  s(() => {
+    const e = (c) => {
+      r();
+    };
+    document.addEventListener("mousedown", e), m(() => {
+      document.removeEventListener("mousedown", e);
+    });
+  });
+}, u = () => n(o.INTLAYER_IFRAME_CLICKED, t);
+export {
+  a as useIframeClickInterceptor,
+  u as useIframeClickMerger
+};