@weavix/sdk-react 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1198 @@
+import He, { Component as Pt, useCallback as Ye, useState as D, useEffect as N, createContext as Ot, useRef as xt, useMemo as kt, useContext as jt } from "react";
+import { on as At, setHandler as Lt, hostApi as P, dispatchHostEvent as B } from "@weavix/sdk-core";
+import { METHOD_NOT_SUPPORTED as yr, MISSING_REQUIRED_SCOPE as Er, PLUGIN_ID_IS_NOT_CORRECT as br, PLUGIN_ID_OR_SLOT_NOT_PROVIDED as Rr, PluginActionError as _r, UNKNOWN_ERROR as wr, VALIDATION_ERROR as Ir, getField as Sr, getLocalizedString as Tr, hostApi as Cr, trackerApi as Pr, uiApi as Or } from "@weavix/sdk-core";
+class Dt extends Pt {
+  static getDerivedStateFromError(r) {
+    return { hasError: !0, error: r };
+  }
+  constructor(r) {
+    super(r), this.state = { hasError: !1, error: null };
+  }
+  componentDidCatch(r, a) {
+    console.error("ErrorBoundary caught an error:", r, a);
+  }
+  render() {
+    return this.state.hasError && this.state.error ? this.props.fallback(this.state.error) : this.props.children;
+  }
+}
+var Q = { exports: {} }, W = {};
+var Ue;
+function Mt() {
+  if (Ue) return W;
+  Ue = 1;
+  var s = He, r = /* @__PURE__ */ Symbol.for("react.element"), a = /* @__PURE__ */ Symbol.for("react.fragment"), i = Object.prototype.hasOwnProperty, u = s.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, d = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function m(p, f, y) {
+    var v, w = {}, O = null, x = null;
+    y !== void 0 && (O = "" + y), f.key !== void 0 && (O = "" + f.key), f.ref !== void 0 && (x = f.ref);
+    for (v in f) i.call(f, v) && !d.hasOwnProperty(v) && (w[v] = f[v]);
+    if (p && p.defaultProps) for (v in f = p.defaultProps, f) w[v] === void 0 && (w[v] = f[v]);
+    return { $$typeof: r, type: p, key: O, ref: x, props: w, _owner: u.current };
+  }
+  return W.Fragment = a, W.jsx = m, W.jsxs = m, W;
+}
+var V = {};
+var Ne;
+function Ut() {
+  return Ne || (Ne = 1, process.env.NODE_ENV !== "production" && (function() {
+    var s = He, r = /* @__PURE__ */ Symbol.for("react.element"), a = /* @__PURE__ */ Symbol.for("react.portal"), i = /* @__PURE__ */ Symbol.for("react.fragment"), u = /* @__PURE__ */ Symbol.for("react.strict_mode"), d = /* @__PURE__ */ Symbol.for("react.profiler"), m = /* @__PURE__ */ Symbol.for("react.provider"), p = /* @__PURE__ */ Symbol.for("react.context"), f = /* @__PURE__ */ Symbol.for("react.forward_ref"), y = /* @__PURE__ */ Symbol.for("react.suspense"), v = /* @__PURE__ */ Symbol.for("react.suspense_list"), w = /* @__PURE__ */ Symbol.for("react.memo"), O = /* @__PURE__ */ Symbol.for("react.lazy"), x = /* @__PURE__ */ Symbol.for("react.offscreen"), C = Symbol.iterator, F = "@@iterator";
+    function A(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var t = C && e[C] || e[F];
+      return typeof t == "function" ? t : null;
+    }
+    var I = s.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function R(e) {
+      {
+        for (var t = arguments.length, n = new Array(t > 1 ? t - 1 : 0), o = 1; o < t; o++)
+          n[o - 1] = arguments[o];
+        ee("error", e, n);
+      }
+    }
+    function ee(e, t, n) {
+      {
+        var o = I.ReactDebugCurrentFrame, g = o.getStackAddendum();
+        g !== "" && (t += "%s", n = n.concat([g]));
+        var h = n.map(function(c) {
+          return String(c);
+        });
+        h.unshift("Warning: " + t), Function.prototype.apply.call(console[e], console, h);
+      }
+    }
+    var te = !1, Ke = !1, Ge = !1, Xe = !1, Qe = !1, fe;
+    fe = /* @__PURE__ */ Symbol.for("react.module.reference");
+    function Ze(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === i || e === d || Qe || e === u || e === y || e === v || Xe || e === x || te || Ke || Ge || typeof e == "object" && e !== null && (e.$$typeof === O || e.$$typeof === w || e.$$typeof === m || e.$$typeof === p || e.$$typeof === f || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === fe || e.getModuleId !== void 0));
+    }
+    function et(e, t, n) {
+      var o = e.displayName;
+      if (o)
+        return o;
+      var g = t.displayName || t.name || "";
+      return g !== "" ? n + "(" + g + ")" : n;
+    }
+    function ge(e) {
+      return e.displayName || "Context";
+    }
+    function L(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && R("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case i:
+          return "Fragment";
+        case a:
+          return "Portal";
+        case d:
+          return "Profiler";
+        case u:
+          return "StrictMode";
+        case y:
+          return "Suspense";
+        case v:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case p:
+            var t = e;
+            return ge(t) + ".Consumer";
+          case m:
+            var n = e;
+            return ge(n._context) + ".Provider";
+          case f:
+            return et(e, e.render, "ForwardRef");
+          case w:
+            var o = e.displayName || null;
+            return o !== null ? o : L(e.type) || "Memo";
+          case O: {
+            var g = e, h = g._payload, c = g._init;
+            try {
+              return L(c(h));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var M = Object.assign, H = 0, he, ve, me, pe, ye, Ee, be;
+    function Re() {
+    }
+    Re.__reactDisabledLog = !0;
+    function tt() {
+      {
+        if (H === 0) {
+          he = console.log, ve = console.info, me = console.warn, pe = console.error, ye = console.group, Ee = console.groupCollapsed, be = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: Re,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        H++;
+      }
+    }
+    function rt() {
+      {
+        if (H--, H === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: M({}, e, {
+              value: he
+            }),
+            info: M({}, e, {
+              value: ve
+            }),
+            warn: M({}, e, {
+              value: me
+            }),
+            error: M({}, e, {
+              value: pe
+            }),
+            group: M({}, e, {
+              value: ye
+            }),
+            groupCollapsed: M({}, e, {
+              value: Ee
+            }),
+            groupEnd: M({}, e, {
+              value: be
+            })
+          });
+        }
+        H < 0 && R("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var re = I.ReactCurrentDispatcher, ne;
+    function J(e, t, n) {
+      {
+        if (ne === void 0)
+          try {
+            throw Error();
+          } catch (g) {
+            var o = g.stack.trim().match(/\n( *(at )?)/);
+            ne = o && o[1] || "";
+          }
+        return `
+` + ne + e;
+      }
+    }
+    var ie = !1, K;
+    {
+      var nt = typeof WeakMap == "function" ? WeakMap : Map;
+      K = new nt();
+    }
+    function _e(e, t) {
+      if (!e || ie)
+        return "";
+      {
+        var n = K.get(e);
+        if (n !== void 0)
+          return n;
+      }
+      var o;
+      ie = !0;
+      var g = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var h;
+      h = re.current, re.current = null, tt();
+      try {
+        if (t) {
+          var c = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(c.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(c, []);
+            } catch (T) {
+              o = T;
+            }
+            Reflect.construct(e, [], c);
+          } else {
+            try {
+              c.call();
+            } catch (T) {
+              o = T;
+            }
+            e.call(c.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (T) {
+            o = T;
+          }
+          e();
+        }
+      } catch (T) {
+        if (T && o && typeof T.stack == "string") {
+          for (var l = T.stack.split(`
+`), S = o.stack.split(`
+`), b = l.length - 1, _ = S.length - 1; b >= 1 && _ >= 0 && l[b] !== S[_]; )
+            _--;
+          for (; b >= 1 && _ >= 0; b--, _--)
+            if (l[b] !== S[_]) {
+              if (b !== 1 || _ !== 1)
+                do
+                  if (b--, _--, _ < 0 || l[b] !== S[_]) {
+                    var k = `
+` + l[b].replace(" at new ", " at ");
+                    return e.displayName && k.includes("<anonymous>") && (k = k.replace("<anonymous>", e.displayName)), typeof e == "function" && K.set(e, k), k;
+                  }
+                while (b >= 1 && _ >= 0);
+              break;
+            }
+        }
+      } finally {
+        ie = !1, re.current = h, rt(), Error.prepareStackTrace = g;
+      }
+      var q = e ? e.displayName || e.name : "", U = q ? J(q) : "";
+      return typeof e == "function" && K.set(e, U), U;
+    }
+    function it(e, t, n) {
+      return _e(e, !1);
+    }
+    function st(e) {
+      var t = e.prototype;
+      return !!(t && t.isReactComponent);
+    }
+    function G(e, t, n) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return _e(e, st(e));
+      if (typeof e == "string")
+        return J(e);
+      switch (e) {
+        case y:
+          return J("Suspense");
+        case v:
+          return J("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case f:
+            return it(e.render);
+          case w:
+            return G(e.type, t, n);
+          case O: {
+            var o = e, g = o._payload, h = o._init;
+            try {
+              return G(h(g), t, n);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Y = Object.prototype.hasOwnProperty, we = {}, Ie = I.ReactDebugCurrentFrame;
+    function X(e) {
+      if (e) {
+        var t = e._owner, n = G(e.type, e._source, t ? t.type : null);
+        Ie.setExtraStackFrame(n);
+      } else
+        Ie.setExtraStackFrame(null);
+    }
+    function at(e, t, n, o, g) {
+      {
+        var h = Function.call.bind(Y);
+        for (var c in e)
+          if (h(e, c)) {
+            var l = void 0;
+            try {
+              if (typeof e[c] != "function") {
+                var S = Error((o || "React class") + ": " + n + " type `" + c + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[c] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw S.name = "Invariant Violation", S;
+              }
+              l = e[c](t, c, o, n, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (b) {
+              l = b;
+            }
+            l && !(l instanceof Error) && (X(g), R("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", o || "React class", n, c, typeof l), X(null)), l instanceof Error && !(l.message in we) && (we[l.message] = !0, X(g), R("Failed %s type: %s", n, l.message), X(null));
+          }
+      }
+    }
+    var ot = Array.isArray;
+    function se(e) {
+      return ot(e);
+    }
+    function ut(e) {
+      {
+        var t = typeof Symbol == "function" && Symbol.toStringTag, n = t && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return n;
+      }
+    }
+    function lt(e) {
+      try {
+        return Se(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Se(e) {
+      return "" + e;
+    }
+    function Te(e) {
+      if (lt(e))
+        return R("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", ut(e)), Se(e);
+    }
+    var Ce = I.ReactCurrentOwner, ct = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, Pe, Oe;
+    function dt(e) {
+      if (Y.call(e, "ref")) {
+        var t = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (t && t.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function ft(e) {
+      if (Y.call(e, "key")) {
+        var t = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (t && t.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function gt(e, t) {
+      typeof e.ref == "string" && Ce.current;
+    }
+    function ht(e, t) {
+      {
+        var n = function() {
+          Pe || (Pe = !0, R("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", t));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    function vt(e, t) {
+      {
+        var n = function() {
+          Oe || (Oe = !0, R("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", t));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    var mt = function(e, t, n, o, g, h, c) {
+      var l = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: r,
+        // Built-in properties that belong on the element
+        type: e,
+        key: t,
+        ref: n,
+        props: c,
+        // Record the component responsible for creating this element.
+        _owner: h
+      };
+      return l._store = {}, Object.defineProperty(l._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(l, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: o
+      }), Object.defineProperty(l, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: g
+      }), Object.freeze && (Object.freeze(l.props), Object.freeze(l)), l;
+    };
+    function pt(e, t, n, o, g) {
+      {
+        var h, c = {}, l = null, S = null;
+        n !== void 0 && (Te(n), l = "" + n), ft(t) && (Te(t.key), l = "" + t.key), dt(t) && (S = t.ref, gt(t, g));
+        for (h in t)
+          Y.call(t, h) && !ct.hasOwnProperty(h) && (c[h] = t[h]);
+        if (e && e.defaultProps) {
+          var b = e.defaultProps;
+          for (h in b)
+            c[h] === void 0 && (c[h] = b[h]);
+        }
+        if (l || S) {
+          var _ = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          l && ht(c, _), S && vt(c, _);
+        }
+        return mt(e, l, S, g, o, Ce.current, c);
+      }
+    }
+    var ae = I.ReactCurrentOwner, xe = I.ReactDebugCurrentFrame;
+    function z(e) {
+      if (e) {
+        var t = e._owner, n = G(e.type, e._source, t ? t.type : null);
+        xe.setExtraStackFrame(n);
+      } else
+        xe.setExtraStackFrame(null);
+    }
+    var oe;
+    oe = !1;
+    function ue(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === r;
+    }
+    function ke() {
+      {
+        if (ae.current) {
+          var e = L(ae.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function yt(e) {
+      return "";
+    }
+    var je = {};
+    function Et(e) {
+      {
+        var t = ke();
+        if (!t) {
+          var n = typeof e == "string" ? e : e.displayName || e.name;
+          n && (t = `
+
+Check the top-level render call using <` + n + ">.");
+        }
+        return t;
+      }
+    }
+    function Ae(e, t) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var n = Et(t);
+        if (je[n])
+          return;
+        je[n] = !0;
+        var o = "";
+        e && e._owner && e._owner !== ae.current && (o = " It was passed a child from " + L(e._owner.type) + "."), z(e), R('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', n, o), z(null);
+      }
+    }
+    function Le(e, t) {
+      {
+        if (typeof e != "object")
+          return;
+        if (se(e))
+          for (var n = 0; n < e.length; n++) {
+            var o = e[n];
+            ue(o) && Ae(o, t);
+          }
+        else if (ue(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var g = A(e);
+          if (typeof g == "function" && g !== e.entries)
+            for (var h = g.call(e), c; !(c = h.next()).done; )
+              ue(c.value) && Ae(c.value, t);
+        }
+      }
+    }
+    function bt(e) {
+      {
+        var t = e.type;
+        if (t == null || typeof t == "string")
+          return;
+        var n;
+        if (typeof t == "function")
+          n = t.propTypes;
+        else if (typeof t == "object" && (t.$$typeof === f || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        t.$$typeof === w))
+          n = t.propTypes;
+        else
+          return;
+        if (n) {
+          var o = L(t);
+          at(n, e.props, "prop", o, e);
+        } else if (t.PropTypes !== void 0 && !oe) {
+          oe = !0;
+          var g = L(t);
+          R("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", g || "Unknown");
+        }
+        typeof t.getDefaultProps == "function" && !t.getDefaultProps.isReactClassApproved && R("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Rt(e) {
+      {
+        for (var t = Object.keys(e.props), n = 0; n < t.length; n++) {
+          var o = t[n];
+          if (o !== "children" && o !== "key") {
+            z(e), R("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", o), z(null);
+            break;
+          }
+        }
+        e.ref !== null && (z(e), R("Invalid attribute `ref` supplied to `React.Fragment`."), z(null));
+      }
+    }
+    var De = {};
+    function Me(e, t, n, o, g, h) {
+      {
+        var c = Ze(e);
+        if (!c) {
+          var l = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (l += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var S = yt();
+          S ? l += S : l += ke();
+          var b;
+          e === null ? b = "null" : se(e) ? b = "array" : e !== void 0 && e.$$typeof === r ? (b = "<" + (L(e.type) || "Unknown") + " />", l = " Did you accidentally export a JSX literal instead of a component?") : b = typeof e, R("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", b, l);
+        }
+        var _ = pt(e, t, n, g, h);
+        if (_ == null)
+          return _;
+        if (c) {
+          var k = t.children;
+          if (k !== void 0)
+            if (o)
+              if (se(k)) {
+                for (var q = 0; q < k.length; q++)
+                  Le(k[q], e);
+                Object.freeze && Object.freeze(k);
+              } else
+                R("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Le(k, e);
+        }
+        if (Y.call(t, "key")) {
+          var U = L(e), T = Object.keys(t).filter(function(Ct) {
+            return Ct !== "key";
+          }), le = T.length > 0 ? "{key: someKey, " + T.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!De[U + le]) {
+            var Tt = T.length > 0 ? "{" + T.join(": ..., ") + ": ...}" : "{}";
+            R(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, le, U, Tt, U), De[U + le] = !0;
+          }
+        }
+        return e === i ? Rt(_) : bt(_), _;
+      }
+    }
+    function _t(e, t, n) {
+      return Me(e, t, n, !0);
+    }
+    function wt(e, t, n) {
+      return Me(e, t, n, !1);
+    }
+    var It = wt, St = _t;
+    V.Fragment = i, V.jsx = It, V.jsxs = St;
+  })()), V;
+}
+var Fe;
+function Nt() {
+  return Fe || (Fe = 1, process.env.NODE_ENV === "production" ? Q.exports = Mt() : Q.exports = Ut()), Q.exports;
+}
+var E = Nt();
+const Ft = ({ error: s }) => /* @__PURE__ */ E.jsx("div", { className: "plugin-error", children: /* @__PURE__ */ E.jsxs("div", { className: "plugin-error__container", children: [
+  /* @__PURE__ */ E.jsxs("div", { className: "plugin-error__header", children: [
+    /* @__PURE__ */ E.jsxs(
+      "svg",
+      {
+        className: "plugin-error__icon",
+        width: "24",
+        height: "24",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        children: [
+          /* @__PURE__ */ E.jsx("circle", { cx: "12", cy: "12", r: "10", fill: "#f44336" }),
+          /* @__PURE__ */ E.jsx(
+            "path",
+            {
+              d: "M12 7v6m0 4h.01",
+              stroke: "white",
+              strokeWidth: "2",
+              strokeLinecap: "round"
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ E.jsx("h3", { className: "plugin-error__title", children: "Ошибка инициализации плагина" })
+  ] }),
+  /* @__PURE__ */ E.jsx("div", { className: "plugin-error__message", children: "Не удалось инициализировать плагин. Проверьте параметры запуска и попробуйте перезагрузить страницу." }),
+  /* @__PURE__ */ E.jsxs("details", { className: "plugin-error__details", children: [
+    /* @__PURE__ */ E.jsx("summary", { className: "plugin-error__summary", children: "Детали ошибки" }),
+    /* @__PURE__ */ E.jsxs("pre", { className: "plugin-error__stack", children: [
+      s.message,
+      s.stack && `
+
+${s.stack}`
+    ] })
+  ] })
+] }) }), ze = Ft, zt = () => /* @__PURE__ */ E.jsx("div", { className: "plugin-loader", children: /* @__PURE__ */ E.jsxs("div", { className: "plugin-loader__content", children: [
+  /* @__PURE__ */ E.jsx("div", { className: "plugin-loader__spinner" }),
+  /* @__PURE__ */ E.jsx("div", { className: "plugin-loader__text", children: "Загрузка плагина..." })
+] }) }), cr = zt, Z = /* @__PURE__ */ new Map(), ce = /* @__PURE__ */ new Map();
+function de(s, r) {
+  let a = Z.get(s);
+  a || (a = /* @__PURE__ */ new Set(), Z.set(s, a));
+  const i = r;
+  if (a.add(i), ce.has(s))
+    try {
+      i(ce.get(s));
+    } catch (u) {
+      console.error(`[EventBus] Error replaying cached value for "${s}":`, u);
+    }
+  return () => {
+    a.delete(i), a.size === 0 && Z.delete(s);
+  };
+}
+function qt(s) {
+  const r = s.method;
+  ce.set(r, s.result);
+  const a = Z.get(r);
+  if (a)
+    for (const i of a)
+      try {
+        i(s.result);
+      } catch (u) {
+        console.error(`[EventBus] Error in subscriber for "${s.method}":`, u);
+      }
+}
+const $t = {};
+function Ht(s) {
+  return $t[s];
+}
+const qe = 6666;
+class $e extends Error {
+  constructor(r, a, i) {
+    super(a), this.name = "PluginActionError", this.code = r, this.errorData = i;
+  }
+}
+class Yt {
+  constructor(r, a, i, u, d, m) {
+    this.pendingRequests = /* @__PURE__ */ new Map(), this.messageListener = null, this.requestTimeout = 1e4, this.pluginId = r, this.elementId = a, this.targetOrigin = d, this.entityId = u, this.entityMeta = m, this.slot = i, this.initListener();
+  }
+  request(r, a, i) {
+    return new Promise((u, d) => {
+      const m = this.generateMessageId(), p = i?.timeout ?? this.requestTimeout, f = {
+        messageId: m,
+        method: r,
+        payload: a
+      }, y = setTimeout(() => {
+        this.pendingRequests.get(m) && (this.pendingRequests.delete(m), d(new Error(`Request timeout: ${r} exceeded ${p}ms`)));
+      }, p);
+      this.pendingRequests.set(m, { resolve: u, reject: d, timeoutId: y });
+      try {
+        this.send(f);
+      } catch (v) {
+        clearTimeout(y), this.pendingRequests.delete(m), d(v);
+      }
+    });
+  }
+  send(r) {
+    window.parent.postMessage(
+      {
+        pluginId: this.pluginId,
+        elementId: this.elementId,
+        slot: this.slot,
+        entityId: this.entityId,
+        entityMeta: this.entityMeta,
+        ...r
+      },
+      this.targetOrigin
+    );
+  }
+  destroy() {
+    this.messageListener && (window.removeEventListener("message", this.messageListener), this.messageListener = null), this.pendingRequests.forEach((r) => {
+      clearTimeout(r.timeoutId);
+    }), this.pendingRequests.clear();
+  }
+  initListener() {
+    this.messageListener = async (r) => {
+      if (r.origin !== this.targetOrigin) {
+        console.info(
+          "[Bridge] Ignored message from origin:",
+          r.origin,
+          "(expected:",
+          this.targetOrigin,
+          ")"
+        );
+        return;
+      }
+      const a = r.data;
+      if (console.info("[Bridge] Received message:", a), a.type === "event") {
+        console.info("[Bridge] Dispatching host event:", a.method, a.result), qt(a);
+        return;
+      }
+      if (console.info("[Bridge] Received message:", r.data), !a.messageId) {
+        console.info("[Bridge] Ignored message without messageId:", a);
+        return;
+      }
+      const i = a, u = this.pendingRequests.get(i.messageId);
+      if (!u) {
+        if (i.type === "request") {
+          const p = i.result.method, f = Ht(p);
+          if (!f) {
+            this.send({
+              messageId: i.messageId,
+              type: "response",
+              result: null,
+              errorCode: qe,
+              error: `No handler for method ${p}`
+            });
+            return;
+          }
+          try {
+            const y = f();
+            this.send({
+              messageId: i.messageId,
+              payload: y,
+              method: "responseData",
+              type: "response"
+            });
+          } catch (y) {
+            const v = y instanceof Error ? y : new Error(String(y)), w = v instanceof $e ? v.code : qe;
+            this.send({
+              messageId: i.messageId,
+              type: "response",
+              result: null,
+              errorCode: w,
+              error: v.message
+            });
+          }
+        }
+        return;
+      }
+      clearTimeout(u.timeoutId), this.pendingRequests.delete(i.messageId);
+      const d = i;
+      d.type === "response" && d.errorCode ? u.reject(
+        new $e(
+          d.errorCode,
+          d.error ?? "Unknown error",
+          d.errorData
+        )
+      ) : u.resolve(d.result);
+    }, window.addEventListener("message", this.messageListener);
+  }
+  generateMessageId() {
+    return crypto.randomUUID();
+  }
+}
+let $ = null;
+function Bt(s, r, a, i, u, d) {
+  return $ && $.destroy(), $ = new Yt(
+    s,
+    r,
+    a,
+    i,
+    u,
+    d
+  ), $;
+}
+function Wt() {
+  if (!$)
+    throw new Error("Bridge not initialized. Call initBridge first.");
+  return $;
+}
+function j(s, r, a) {
+  return Wt().request(s, r, a);
+}
+const Vt = 3e5;
+class Jt {
+  show(r) {
+    return j("confirm.show", r, {
+      timeout: Vt
+    });
+  }
+}
+class Kt {
+  constructor() {
+    this.callbackMap = /* @__PURE__ */ new Map(), this.toastActionIds = /* @__PURE__ */ new Map(), this.eventSubscribed = !1;
+  }
+  async add(r) {
+    this.ensureEventSubscription();
+    const a = [], i = r.actions?.map((m) => {
+      const p = crypto.randomUUID();
+      return this.callbackMap.set(p, m.onClick), a.push(p), { id: p, label: m.label };
+    }), u = await j("toast.add", {
+      name: r.name,
+      title: r.title,
+      content: r.content,
+      theme: r.theme,
+      autoHiding: r.autoHiding,
+      isClosable: r.isClosable,
+      actions: i
+    });
+    a.length > 0 && this.toastActionIds.set(u.name, a);
+    const d = r.autoHiding ?? 5e3;
+    return setTimeout(() => this.cleanupCallbacksForToast(u.name), d + 1e3), u;
+  }
+  ensureEventSubscription() {
+    this.eventSubscribed || (this.eventSubscribed = !0, de("toast.action.clicked", ({ name: r, actionId: a }) => {
+      this.callbackMap.get(a)?.(), this.cleanupCallbacksForToast(r);
+    }));
+  }
+  cleanupCallbacksForToast(r) {
+    const a = this.toastActionIds.get(r);
+    if (a) {
+      for (const i of a)
+        this.callbackMap.delete(i);
+      this.toastActionIds.delete(r);
+    }
+  }
+}
+class Gt {
+  constructor() {
+    this.toaster = new Kt(), this.confirm = new Jt();
+  }
+}
+const Be = new Gt();
+function Xt(s, r, a = "ru") {
+  if (typeof s == "string")
+    return s;
+  const i = (r ?? a).toLowerCase(), u = a.toLowerCase();
+  return s[i] || s[u] || s.ru || s.en || "";
+}
+class Qt {
+  constructor(r) {
+    this.lastHeight = 0, this.isUpdating = !1, this.consecutiveSmallIncreases = 0, this.MAX_CONSECUTIVE_SMALL_INCREASES = 5, this.SMALL_INCREASE_THRESHOLD_PX = 10, this.resizeCallback = r;
+  }
+  enable() {
+    if (!document.body) {
+      console.error("[AutoResize] document.body does not exist yet");
+      return;
+    }
+    const r = async () => {
+      if (this.isUpdating)
+        return;
+      const i = document.getElementById("root"), u = window.getComputedStyle(document.body), d = parseInt(u.marginTop, 10) || 0, m = parseInt(u.marginBottom, 10) || 0, f = Math.max(
+        document.body.scrollHeight,
+        document.body.offsetHeight,
+        i ? i.scrollHeight + d + m : 0
+      ) + 4;
+      if (f !== this.lastHeight) {
+        if (f > this.lastHeight)
+          if (f - this.lastHeight <= this.SMALL_INCREASE_THRESHOLD_PX) {
+            if (this.consecutiveSmallIncreases++, this.consecutiveSmallIncreases > this.MAX_CONSECUTIVE_SMALL_INCREASES) {
+              console.warn(
+                "[AutoResize] Infinite loop detected. Stopping auto-resize. This may be caused by elements with viewport-relative units (vh, %)."
+              ), this.disable();
+              return;
+            }
+          } else
+            this.consecutiveSmallIncreases = 0;
+        else
+          this.consecutiveSmallIncreases = 0;
+        this.isUpdating = !0, this.lastHeight = f;
+        try {
+          await this.resizeCallback(f);
+        } catch (y) {
+          console.error("[AutoResize] Failed to update content size:", y);
+        } finally {
+          this.isUpdating = !1;
+        }
+      }
+    }, a = () => {
+      clearTimeout(this.resizeTimeout), this.resizeTimeout = setTimeout(r, 100);
+    };
+    this.resizeObserver = new ResizeObserver(a), this.resizeObserver.observe(document.body), r();
+  }
+  disable() {
+    this.resizeObserver?.disconnect(), clearTimeout(this.resizeTimeout), this.isUpdating = !1, this.consecutiveSmallIncreases = 0;
+  }
+}
+class Zt {
+  constructor() {
+    this.slot = null, this.service = null, this.origin = null, this.innerUrl = null, this.queryParams = null;
+  }
+  getTheme() {
+    return j("theme.get");
+  }
+  getLanguage() {
+    return j("language.get");
+  }
+  getUserId() {
+    return j("userId.get");
+  }
+  getIsYateam() {
+    return j("isYateam.get");
+  }
+  getContext() {
+    return j("context.get");
+  }
+  updateContentSize(r) {
+    return j("contentSize.update", r);
+  }
+  notifyReady() {
+    return j("plugin.ready");
+  }
+  close(r) {
+    return j("plugin.close", r);
+  }
+  navigate(r) {
+    return j("navigate", r);
+  }
+  init(r) {
+    const { autoResize: a = !0 } = r, i = new URLSearchParams(location.search);
+    if (this.service = i.get("service"), this.service === null)
+      throw new Error("Service is not defined");
+    const u = i.get("slot");
+    if (!u)
+      throw new Error("Slot is not defined");
+    const d = i.get("parentOrigin");
+    if (!d)
+      throw new Error("Target origin is not defined");
+    const m = i.get("id");
+    if (!m)
+      throw new Error("Plugin id is not defined");
+    const p = i.get("elementId");
+    if (!p)
+      throw new Error("Element id is not defined");
+    const f = i.get("entityId"), y = i.get("entityMeta"), v = y ? JSON.parse(y) : void 0;
+    Bt(m, p, u, f, d, v), this.slot = u, this.origin = d, this.innerUrl = i.get("innerUrl") ?? "";
+    const w = i.get("queryParams");
+    this.queryParams = w ? JSON.parse(decodeURIComponent(w)) : {}, a && (this.autoResizeManager = new Qt(
+      (O) => this.updateContentSize({ height: O })
+    ), this.autoResizeManager.enable());
+  }
+  getSlot() {
+    if (this.slot === null)
+      throw new Error("Plugin not initialized. Call init() first.");
+    return this.slot;
+  }
+  getService() {
+    if (this.service === null)
+      throw new Error("Service not initialized. Call init() first.");
+    return this.service;
+  }
+  getOrigin() {
+    if (this.origin === null)
+      throw new Error("Origin not initialized. Call init() first.");
+    return this.origin;
+  }
+  getInnerUrl() {
+    if (this.innerUrl === null)
+      throw new Error("Plugin not initialized. Call init() first.");
+    return this.innerUrl;
+  }
+  getQueryParams() {
+    if (this.queryParams === null)
+      throw new Error("Plugin not initialized. Call init() first.");
+    return this.queryParams;
+  }
+  disableAutoResize() {
+    this.autoResizeManager?.disable();
+  }
+}
+const We = new Zt(), er = () => ({ show: Ye((r) => Be.confirm.show(r), []) }), dr = er;
+function tr() {
+  const [s, r] = D(void 0);
+  return N(() => {
+    (async () => {
+      const i = await We.getIsYateam();
+      r(i);
+    })();
+  }, []), s;
+}
+function Ve() {
+  const [s, r] = D(void 0);
+  return N(() => de("language.changed", (i) => {
+    r(i);
+  }), []), s;
+}
+const rr = (s = "ru") => {
+  const r = Ve();
+  return (a) => Xt(a, r, s);
+}, fr = rr;
+function nr() {
+  const [s, r] = D(void 0);
+  return N(() => de("theme.changed", (i) => {
+    r(i);
+  }), []), s;
+}
+const ir = () => ({ add: Ye((r) => Be.toaster.add(r), []) }), gr = ir;
+function sr() {
+  const [s, r] = D(void 0);
+  return N(() => {
+    (async () => {
+      const i = await We.getUserId();
+      r(i);
+    })();
+  }, []), s;
+}
+function ar() {
+  const [s, r] = D(void 0);
+  return N(() => At("context.changed", (i) => {
+    r(i);
+  }), []), s;
+}
+const Je = Ot(null);
+function hr() {
+  const s = jt(Je);
+  if (!s)
+    throw new Error("useTrackerPluginContext must be used within TrackerPluginProvider");
+  const r = nr(), a = Ve(), i = tr(), u = sr(), d = ar();
+  return {
+    service: P.getService(),
+    origin: P.getOrigin(),
+    slot: s.slot,
+    innerUrl: s.innerUrl,
+    queryParams: s.queryParams,
+    registerHandler: s.registerHandler,
+    theme: r,
+    language: a,
+    slotContext: d,
+    isYateam: i,
+    userId: u
+  };
+}
+const or = (s) => {
+  try {
+    return new URL(s, window.location.href).origin === window.location.origin;
+  } catch {
+    return !0;
+  }
+};
+function vr({
+  children: s,
+  autoResize: r = !0,
+  fallback: a,
+  errorFallback: i,
+  autoNotifyReady: u = !0
+}) {
+  const d = xt(!1), [m, p] = D(!1), [f, y] = D(null), [v, w] = D(null), O = kt(() => (x, C) => Lt(x, C), []);
+  return N(() => {
+    const x = (C) => {
+      const A = C.target.closest("[href], [data-href]");
+      if (!A) return;
+      const I = A.getAttribute("href") || A.getAttribute("data-href");
+      if (!I || or(I))
+        return;
+      C.preventDefault();
+      const ee = A.getAttribute("target") === "_blank";
+      P.navigate({
+        path: I,
+        options: {
+          newTab: ee
+        }
+      }).then(() => {
+        console.info(`Navigation: ${I}`);
+      }).catch((te) => {
+        console.error("Navigation error:", te);
+      });
+    };
+    return document.addEventListener("click", x), () => {
+      document.removeEventListener("click", x);
+    };
+  }, []), N(() => {
+    if (d.current)
+      return;
+    (async () => {
+      try {
+        P.init({ autoResize: r }), d.current = !0, w({
+          slot: P.getSlot(),
+          innerUrl: P.getInnerUrl(),
+          queryParams: P.getQueryParams(),
+          registerHandler: O
+        }), u && await P.notifyReady();
+        const [C, F, A, I, R] = await Promise.allSettled([
+          P.getTheme(),
+          P.getLanguage(),
+          P.getContext(),
+          P.getIsYateam(),
+          P.getUserId()
+        ]);
+        C.status === "fulfilled" && C.value && B({
+          messageId: "",
+          type: "event",
+          method: "theme.changed",
+          result: C.value
+        }), F.status === "fulfilled" && F.value && B({
+          messageId: "",
+          type: "event",
+          method: "language.changed",
+          result: F.value
+        }), I.status === "fulfilled" && I.value && B({
+          messageId: "",
+          type: "event",
+          method: "isYateam.changed",
+          result: I.value
+        }), R.status === "fulfilled" && R.value && B({
+          messageId: "",
+          type: "event",
+          method: "userId.changed",
+          result: R.value
+        }), A.status === "fulfilled" && A.value && B({
+          messageId: "",
+          type: "event",
+          method: "context.changed",
+          result: A.value
+        }), p(!0);
+      } catch (C) {
+        y(C);
+      }
+    })();
+  }, [r, O, u]), f ? i ? /* @__PURE__ */ E.jsx(E.Fragment, { children: i(f) }) : /* @__PURE__ */ E.jsx(ze, { error: f }) : !m || !v ? /* @__PURE__ */ E.jsx(E.Fragment, { children: a }) : /* @__PURE__ */ E.jsx(
+    Dt,
+    {
+      fallback: i || ((x) => /* @__PURE__ */ E.jsx(ze, { error: x })),
+      children: /* @__PURE__ */ E.jsx(Je.Provider, { value: v, children: s })
+    }
+  );
+}
+export {
+  yr as METHOD_NOT_SUPPORTED,
+  Er as MISSING_REQUIRED_SCOPE,
+  br as PLUGIN_ID_IS_NOT_CORRECT,
+  Rr as PLUGIN_ID_OR_SLOT_NOT_PROVIDED,
+  _r as PluginActionError,
+  ze as PluginError,
+  cr as PluginLoader,
+  vr as TrackerPluginProvider,
+  wr as UNKNOWN_ERROR,
+  Ir as VALIDATION_ERROR,
+  Sr as getField,
+  Tr as getLocalizedString,
+  Cr as hostApi,
+  Pr as trackerApi,
+  Or as uiApi,
+  dr as useConfirm,
+  fr as useLocalizedString,
+  gr as useToaster,
+  hr as useTrackerPluginContext
+};
+//# sourceMappingURL=index.mjs.map