@telia-ace/widget-core 0.0.1

package/index.mjs

@@ -0,0 +1,910 @@
+import { bootstrapImplementation as H, ConfigurationApi as B } from "@webprovisions/bootstrapping";
+import { selectImplementations as M, createConfigurationApi as V, version as j, Environment as q, Implementation as z, Plugin as Q, WidgetType as F } from "@webprovisions/platform";
+import { uuid as E, Logger as O } from "@telia-ace/widget-utilities";
+class at {
+  constructor(t) {
+    const { events: e } = t.get("$widget");
+    this.events = e.createChild(this);
+  }
+  action(t, e, s) {
+    this.events.dispatch(
+      "data:action",
+      { action: e, value: s, target: t },
+      { bubbles: !0 }
+    );
+  }
+  subscribe(t, e) {
+    return this.events.subscribe(
+      "data:action",
+      (s, { action: i, value: c, target: o }) => t === o && e(t, i, c)
+    );
+  }
+}
+const pt = (n, t, e = {}) => H(
+  n,
+  n.bindings,
+  () => {
+    const s = n.container.get("$runtimecfg").map((i) => {
+      const c = i[0];
+      if (typeof c == "function")
+        return c;
+      if (M(c)(n))
+        return i[1];
+    }).filter((i) => !!i);
+    return (t ? [t] : []).concat(
+      s
+    );
+  },
+  e.rootElementResolver || (() => document.body)
+), G = (n) => {
+  const t = [];
+  return [
+    (s, i) => {
+      t.push(n.subscribe(s, i));
+    },
+    () => {
+      t.forEach((s) => {
+        s();
+      });
+    }
+  ];
+};
+class N {
+  constructor(t, e = []) {
+    this.platform = t, this.rules = e;
+  }
+  match(t) {
+    return this.rules.every((e) => !(e.id && e.id !== t.id || e.type && e.type !== t.type));
+  }
+  ofType(t) {
+    return this.rules.push({ type: t }), this;
+  }
+  withId(t) {
+    return this.rules.push({ id: t }), this;
+  }
+  select() {
+    return new K(this.platform, this);
+  }
+}
+class S {
+  constructor(t, e, s) {
+    this.platform = t, this.node = e, this.actions = new P(
+      t,
+      new N(t).withId(e.id),
+      s
+    );
+    const [i, c] = G(
+      this.platform.events
+    );
+    this.subscribe = i, this.unsubscribe = c;
+  }
+  properties(t) {
+    return t && this.node.touchProperties((e) => t(e)), this.node.attributes.properties;
+  }
+  context(t) {
+    return t && this.subscribe("components:context-changed", (e, { node: s }) => {
+      s === this.node && t(this.node.attributes.context);
+    }), this.node.attributes.context;
+  }
+  layout(t) {
+    return t && this.subscribe("components:layout-changed", (e, { node: s }) => {
+      s === this.node && t(this.node.attributes.layout);
+    }), this.node.attributes.layout;
+  }
+  writeProperties(t, e) {
+    this.node.writeProperties(t, e);
+  }
+  writeContext(t, e) {
+    this.node.writeProperties(t, e);
+  }
+  writeLayout(t, e) {
+    this.node.writeLayout(t, e);
+  }
+  dispose() {
+    this.unsubscribe(), this.actions.dispose();
+  }
+}
+class K {
+  constructor(t, e, s = !0) {
+    this.platform = t, this.target = e, this.clearOnDispose = s, this.removes = [], this.actions = new P(this.platform, this.target);
+  }
+  writeProperties(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { properties: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeContext(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { context: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  writeLayout(t, e) {
+    this.removes.push(
+      this.platform.write({
+        options: e,
+        attributes: { layout: t },
+        target: this.target,
+        removable: this.clearOnDispose
+      })
+    );
+  }
+  dispose() {
+    this.removes.forEach((t) => {
+      t();
+    }), this.actions.dispose();
+  }
+}
+const U = (n, t, e) => {
+  const s = n.concat(), i = (c, o, a) => {
+    let u = !0;
+    if (s.length) {
+      const h = s.shift(), r = (p, l) => (u = !1, i(
+        p,
+        Object.assign({}, o, l),
+        a
+      ));
+      return Promise.resolve(h(c, r, a)).then(
+        (p) => ({
+          ...p,
+          cancelled: u
+        })
+      );
+    }
+    return Promise.resolve({ data: c, cancelled: !1, options: o });
+  };
+  return i(t, {}, e);
+};
+class P {
+  constructor(t, e, s) {
+    this.platform = t, this.target = e, this.ns = s, this.subscriptions = [], this.create = this.create.bind(this);
+  }
+  create(t, e = () => {
+  }) {
+    const s = {
+      key: t,
+      fn: e,
+      target: this.target,
+      ns: this.ns
+    };
+    this.platform.actionsState.handlers.push(s);
+    const i = () => {
+      const c = this.platform.actionsState.handlers.indexOf(s);
+      c > -1 && this.platform.actionsState.handlers.splice(c, 1);
+    };
+    return this.subscriptions.push(i), i;
+  }
+  dispatch(t, e) {
+    const s = this.platform.nodes.all.concat(
+      this.platform.nodes.detached
+    ), i = {}, c = this.platform.actionsState.handlers.filter(
+      (o) => o.key === t && (!o.ns || !this.ns || o.ns === this.ns)
+    );
+    return Promise.all(
+      c.map((o) => {
+        const a = s.filter(
+          (h) => o.target.match(h) && this.target.match(h)
+        ), u = this.platform.actionsState.watchers.filter((h) => h.key === t && (!h.ns || !this.ns || h.ns === this.ns) && a.some(
+          (r) => h.target.match(r)
+        )).map((h) => h.fn);
+        return Promise.all(
+          a.map((h) => {
+            const r = new S(
+              this.platform,
+              h,
+              this.ns
+            );
+            return U(u, e, r).then(
+              (p) => {
+                const { data: l = {}, options: d, cancelled: b } = p;
+                return Promise.resolve(
+                  b ? {} : o.fn(l, d, r)
+                ).then((g) => {
+                  i[h.id] = g;
+                });
+              }
+            );
+          })
+        );
+      })
+    ).then(() => i);
+  }
+  watch(t, e) {
+    let s = t, i = this.ns;
+    const c = t.split(".");
+    c.length > 1 && (i = c[0], s = c.splice(1).join("."));
+    const o = {
+      fn: e,
+      target: this.target,
+      key: s,
+      ns: i
+    };
+    this.platform.actionsState.watchers.push(o);
+    const a = () => {
+      const u = this.platform.actionsState.watchers.indexOf(o);
+      u > -1 && this.platform.actionsState.watchers.splice(u, 1);
+    };
+    return this.subscriptions.push(a), a;
+  }
+  dispose() {
+    this.subscriptions.forEach((t) => t());
+  }
+}
+const ut = V((n) => {
+  n.createCommand("components", (t) => (e) => {
+    t.events.subscribeOnce(
+      "components:platform-created",
+      (s, { platform: i }) => {
+        e.handlers && e.handlers.forEach(([c, o]) => {
+          i.addComponentHandler(c, o);
+        });
+      }
+    );
+  });
+});
+class I {
+  constructor(t, e) {
+    this.events = t, this.tags = [], this.children = {}, this.changesets = [], this.mountCount = 0, this.id = E(), this.type = e, this.attributes = {
+      context: {},
+      properties: {},
+      layout: {},
+      tags: []
+    }, this.writeLayout({ size: "full", indent: 0 });
+  }
+  mount(t, e) {
+    let s = t.get("mounted-nodes");
+    return s || (s = /* @__PURE__ */ new Map(), t.register("mounted-nodes", s)), s.has(this) ? (process.env.NODE_ENV !== "production" && O.error(
+      "Trying to mount an already mounted component node.",
+      this
+    ), () => {
+    }) : (this.events.dispatch("components:node-mounted", { node: this }), this.mountCount === 0 && (this.mountCount = this.mountCount + 1, this.events.dispatch("components:node-enter", { node: this })), () => {
+      s.delete(this), this.events.dispatch("components:node-unmounted", { node: this }), this.mountCount = this.mountCount - 1, this.mountCount === 0 && this.events.dispatch("components:node-exit", { node: this });
+    });
+  }
+  appendChild(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
+        return;
+      t.parent.removeChild(t);
+    }
+    t.parent = this, this.children[e] || (this.children[e] = []), this.children[e].push(t), this.events.dispatch("components:node-appended", { node: t });
+  }
+  prependChild(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
+        return;
+      t.parent.removeChild(t);
+    }
+    t.parent = this, this.children[e] || (this.children[e] = []), this.children[e].unshift(t), this.events.dispatch("components:node-appended", { node: t });
+  }
+  touchProperties(t, e = {}, s) {
+    const c = [{ properties: t }, e];
+    return this.changesets.push(c), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (s) {
+        const o = this.changesets.indexOf(c);
+        o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeProperties(t, e = {}, s) {
+    const c = [{ properties: t }, e];
+    return this.changesets.push(c), this.events.dispatch("components:set-properties", { node: this }), () => {
+      if (s) {
+        const o = this.changesets.indexOf(c);
+        o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-properties", { node: this }));
+      }
+    };
+  }
+  writeLayout(t, e = {}, s) {
+    const c = [{ layout: t }, e];
+    return this.changesets.push(c), this.events.dispatch("components:set-layout", { node: this }), () => {
+      if (!s)
+        return;
+      const o = this.changesets.indexOf(c);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-layout", { node: this }));
+    };
+  }
+  writeContext(t, e = {}, s) {
+    const c = [{ context: t }, e];
+    return this.changesets.push(c), this.events.dispatch("components:set-context", { node: this }), () => {
+      if (!s)
+        return;
+      const o = this.changesets.indexOf(c);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-context", { node: this }));
+    };
+  }
+  getChildren(t = "default") {
+    const e = this.children[t] || [];
+    return e.reduce((s, i, c) => {
+      const { order: o = c } = i.attributes.layout;
+      return s[o] ? s.splice(o, 0, i) : s[o] = i, s;
+    }, Array(e.length));
+  }
+  remove() {
+    this.parent && this.parent.removeChild(this);
+  }
+  removeChild(t) {
+    Object.keys(this.children).forEach((e) => {
+      const s = this.children[e], i = s.indexOf(t);
+      i > -1 && (s.splice(i, 1), this.events.dispatch("components:node-removed", {
+        node: t,
+        parentNode: this
+      }));
+    }), delete t.parent;
+  }
+}
+const D = (n, t, e) => {
+  for (let s = 0, i = n.length; s < i && e(n[s]) !== !0; s++) {
+    const c = t[n[s].id] || "default", o = n[s].getChildren(c);
+    D(o, t, e);
+  }
+}, k = (n, t, e) => {
+  if (e(n) !== !0) {
+    const s = t[n.id] || "default", i = n.children[s];
+    D(i, t, e);
+  }
+}, x = (n, t) => {
+  const e = [];
+  return k(n, t, (s) => {
+    e.push(s);
+  }), e;
+}, W = (n, t, e) => {
+  let s;
+  return k(n, t, (i) => {
+    if (e(i))
+      return s = i, !0;
+  }), s;
+};
+class Y {
+  constructor(t, e, s) {
+    this.root = t, this.switches = e, this.all = [], this.visible = [], this.detached = [], s.subscribe(
+      "components:node-appended",
+      (i, c) => {
+        this.all.push(c.node), this.visible = x(t, e);
+      }
+    ), s.subscribe(
+      "components:node-removed",
+      (i, c) => {
+        let o = this.all.indexOf(c.node);
+        o > -1 && this.all.splice(o, 1), o = this.visible.indexOf(c.node), o > -1 && this.visible.splice(o, 1), this.visible = x(t, e);
+      }
+    ), s.subscribe(
+      "components:node-switched",
+      (i, c) => {
+        this.visible = x(t, e);
+      }
+    );
+  }
+  query(t = {}) {
+    const e = [];
+    return k(this.root, this.switches, (s) => {
+      Object.keys(t).every((c) => t[c] === s[c]) && e.push(s);
+    }), e;
+  }
+  get(t) {
+    return W(this.root, this.switches, (e) => e.id === t) || this.detached.find((e) => e.id === t);
+  }
+}
+class J {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  add(t, e) {
+    this.handlers.set(t, e);
+  }
+  get(t) {
+    return this.handlers.get(t);
+  }
+}
+const X = (n) => {
+  let t = n, e = 0;
+  for (; t.parent; )
+    e = e + 1, t = t.parent;
+  return e;
+}, Z = (n) => n.map(
+  ([e, s]) => [X(e), e, s]
+).sort(([e], [s]) => e - s).map(([, e, s]) => [e, s]), w = (n) => n instanceof Date ? !1 : n && typeof n == "object" && !Array.isArray(n), v = (n, ...t) => {
+  if (!t.length)
+    return n;
+  const e = t.shift();
+  if (w(n) && w(e))
+    for (const s in e)
+      w(e[s]) ? (n[s] || Object.assign(n, { [s]: {} }), v(n[s], e[s])) : Object.assign(n, { [s]: e[s] });
+  return v(n, ...t);
+}, tt = (n, t) => !n || n === "all" ? !0 : n.some((e) => t.indexOf(e) > -1), et = (n, t) => {
+  let e = [], s = [], i;
+  const c = () => {
+    process.env.NODE_ENV !== "production" && console.time("state-processor.flush");
+    const a = /* @__PURE__ */ new Map(), u = Z(
+      e.map((r, p) => [r, s[p]])
+    ), h = (r, p) => {
+      var T;
+      const l = a.get(r) || {}, d = p.context && !l.context, b = p.properties && !l.properties, g = p.layout && !l.layout;
+      a.set(r, {
+        context: l.context || d,
+        properties: l.properties || b,
+        layout: l.layout || g
+      }), b && (r.attributes.properties = {}), g && (r.attributes.layout = {}), d && (r.attributes.context = v(
+        {},
+        (T = r.parent) == null ? void 0 : T.attributes.context
+      ));
+      const $ = [], R = [], A = [];
+      if (r.changesets.forEach((f) => {
+        const [m, y] = f;
+        tt(y.breakpoints, n.breakpoints) && (b && (typeof m.properties == "function" ? $.push(
+          m.properties
+        ) : v(r.attributes.properties, m.properties)), g && (typeof m.layout == "function" ? R.push(m.layout) : v(r.attributes.layout, m.layout)), d && (typeof m.context == "function" ? A.push(
+          m.context
+        ) : v(r.attributes.context, m.context)));
+      }), $.forEach((f) => {
+        v(
+          r.attributes.properties,
+          f(r.attributes.properties)
+        );
+      }), R.forEach((f) => {
+        v(r.attributes.layout, f(r.attributes.layout));
+      }), A.forEach((f) => {
+        v(r.attributes.context, f(r.attributes.context));
+      }), d || p.recursive) {
+        const f = n.getBranch(r), m = p.recursive ? p : {
+          context: !!d
+        };
+        r.getChildren(f).forEach((y) => {
+          h(y, m);
+        });
+      }
+    };
+    process.env.NODE_ENV !== "production" && console.timeEnd("state-processor.flush"), u.forEach(([r, p]) => {
+      h(r, p);
+    }), e = [], s = [], t(a);
+  }, o = () => {
+    clearTimeout(i), i = setTimeout(c, 0);
+  };
+  return (a, u) => {
+    const h = e.indexOf(a);
+    if (h > -1) {
+      const r = s[h];
+      return u.context && (r.context = !0), u.properties && (r.properties = !0), u.layout && (r.layout = !0), u.recursive && (r.recursive = !0), o();
+    }
+    return e.push(a), s.push(u), o();
+  };
+};
+class st {
+  constructor(t, e = {}) {
+    this.providers = e, this.breakpoints = [], this.actionsState = { handlers: [], watchers: [] }, this.switches = {}, this.changesets = [], this.subscriptions = [], this.customComponentHandler = new J(), this.events = t.events.createChild(this);
+    const s = new I(this.events, "root");
+    s.name = `root-${t.name}`, this.nodes = new Y(s, this.switches, this.events);
+    const i = this.processNode = et(
+      this,
+      (c) => {
+        const o = Array.from(c.keys());
+        process.env.NODE_ENV !== "production" && console.info(`STATE PROCESSOR: ${o.length} node(s) processed:
+          ${o.map(
+          (a) => `${a.name || "<no name>"} (${a.id})
+          `
+        )}`), o.forEach((a) => {
+          const u = c.get(a);
+          a.parent && a.parent.type === "root" && this.events.dispatch("components:root-children-changed", { node: a }), u != null && u.context && this.events.dispatch("components:context-changed", { node: a }), u != null && u.properties && this.events.dispatch("components:properties-changed", { node: a }), u != null && u.layout && this.events.dispatch("components:layout-changed", { node: a });
+        }), this.events.dispatch(
+          "components:component-model-initialized",
+          {},
+          { bubbles: !0 }
+        );
+      }
+    );
+    Promise.all(
+      Object.keys(e).map((c) => e[c].load(this))
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (c, o) => {
+          const { node: a } = o;
+          this.changesets.forEach((u) => {
+            const { changeset: h, target: r, removes: p } = u, [l, d] = h;
+            r.match(o.node) && (l.properties && p.push(a.writeProperties(l.properties, d)), l.context && p.push(a.writeContext(l.context, d)), l.layout && p.push(a.writeLayout(l.layout, d)));
+          });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-appended",
+        (c, o) => {
+          i(o.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-properties",
+        (c, o) => {
+          i(o.node, { properties: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-context",
+        (c, o) => {
+          i(o.node, { properties: !0, context: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-indent",
+        (c, o) => {
+          i(o.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:set-layout",
+        (c, o) => {
+          i(o.node, { layout: !0 });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-switched",
+        (c, { node: o, branch: a }) => {
+          i(o, {
+            layout: !0,
+            recursive: !0,
+            properties: !0,
+            context: !0
+          });
+        }
+      )
+    ), this.subscriptions.push(
+      this.events.subscribe(
+        "components:node-removed",
+        (c, { parentNode: o }) => {
+          i(o, { properties: !0 });
+        }
+      )
+    ), this.events.parent && this.events.parent.dispatch("components:platform-created", {
+      platform: this
+    });
+  }
+  static getInstance(t) {
+    return t.getAsync("components");
+  }
+  addBreakpoint(t) {
+    this.breakpoints.indexOf(t) === -1 && (this.breakpoints.push(t), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  removeBreakpoint(t) {
+    const e = this.breakpoints.indexOf(t);
+    e > -1 && (this.breakpoints.splice(e, 1), this.processNode(this.nodes.root, {
+      context: !0,
+      properties: !0,
+      layout: !0,
+      recursive: !0
+    }));
+  }
+  setSwitch(t, e) {
+    this.switches[t.id] = e, this.events.dispatch("components:node-switched", { node: t, branch: e });
+  }
+  getBranch(t) {
+    return this.switches[t.id];
+  }
+  /**
+   * Creates a `ComponentNode` of the specified type.
+   * @param type Type of node.
+   */
+  createNode(t, e = {}) {
+    const s = new I(this.events, t);
+    return e.detached && this.nodes.detached.push(s), s;
+  }
+  components() {
+    return new N(this);
+  }
+  actions(t, e) {
+    return new P(this, t, e);
+  }
+  write(t) {
+    const {
+      provider: e,
+      target: s,
+      attributes: i,
+      options: c = {},
+      removable: o
+    } = t, a = t.key || E(), h = { changeset: [i, c], target: s, removes: [] };
+    if (e) {
+      const r = this.providers[e];
+      r.write(a, s, i, c), h.removes.push(() => {
+        r.remove(a);
+      });
+    }
+    return this.changesets.push(h), this.nodes.all.forEach((r) => {
+      if (s.match(r)) {
+        let p = () => {
+        };
+        i.properties && (p = r.writeProperties(
+          i.properties,
+          c,
+          o
+        )), i.context && (p = r.writeContext(i.context, c, o)), i.layout && (p = r.writeContext(i.layout, c, o)), h.removes.push(p);
+      }
+    }), () => {
+      if (o) {
+        h.removes.forEach((p) => p());
+        const r = this.changesets.indexOf(h);
+        r > -1 && this.changesets.splice(r, 1);
+      }
+    };
+  }
+  addComponentHandler(t, e) {
+    this.customComponentHandler.add(t, e);
+  }
+  getComponentHandler(t) {
+    return this.customComponentHandler.get(t);
+  }
+  dispose() {
+    this.subscriptions.forEach((t) => t());
+  }
+}
+const nt = (n) => {
+  if (Array.isArray(n)) {
+    const [t, ...e] = n;
+    return {
+      definitionId: t,
+      overrides: e
+    };
+  }
+  return {
+    definitionId: n,
+    overrides: []
+  };
+}, C = (n, t, e, s, i, c) => {
+  e.forEach((o) => {
+    const a = nt(o), u = s[a.definitionId];
+    if (a.definitionId === "view") {
+      const h = n.createNode("view");
+      h.name = "view", Object.keys(i).forEach((r) => {
+        const p = i[r];
+        C(
+          n,
+          h,
+          [p.entry],
+          s,
+          i,
+          r
+        );
+      }), t.appendChild(h), a.overrides.forEach((r) => {
+        r.properties && h.writeProperties(r.properties, {
+          breakpoints: r.breakpoints
+        }), r.context && h.writeContext(r.context, {
+          breakpoints: r.breakpoints
+        }), r.layout && h.writeLayout(r.layout, {
+          breakpoints: r.breakpoints
+        });
+      });
+    } else if (n.getComponentHandler(u.type)) {
+      const h = n.getComponentHandler(u.type);
+      h && h(a, {
+        platform: n,
+        node: t,
+        references: e,
+        definitions: s,
+        views: i,
+        branch: c
+      });
+    } else {
+      const h = s[a.definitionId];
+      if (process.env.NODE_ENV !== "production" && !h) {
+        O.error(
+          `No definition found for component type '${a.definitionId}'.`
+        );
+        return;
+      }
+      const r = n.createNode(h.type);
+      r.name = a.definitionId, r.tags = h.tags || [], h.properties && r.writeProperties(h.properties), h.context && r.writeContext(h.context), h.layout && r.writeLayout(h.layout), t.appendChild(r, c), a.overrides.forEach((p) => {
+        const l = { breakpoints: p.breakpoints };
+        p.properties && r.writeProperties(p.properties, l), p.context && r.writeContext(p.context, l), p.layout && r.writeLayout(p.layout, l);
+      }), h.children && C(
+        n,
+        r,
+        h.children,
+        s,
+        i
+      );
+    }
+  });
+}, lt = (n, t) => {
+  const { entry: e, components: s, breakpoints: i, views: c } = t, o = [];
+  return Object.keys(i).forEach((a) => {
+    const u = i[a], h = window.matchMedia(u);
+    h.matches && n.breakpoints.push(a);
+    const r = (p) => {
+      p.matches ? n.addBreakpoint(a) : n.removeBreakpoint(a);
+    };
+    h.addListener(r), o.push(() => h.removeListener(r));
+  }), C(n, n.nodes.root, [e], s, c), () => o.forEach((a) => {
+    a();
+  });
+}, dt = (n, t) => ({
+  id: n.id,
+  type: n.type,
+  name: n.name,
+  branch: t || "default"
+}), mt = (n, t, e, s = E(), i = {}) => n.getAsync("components").then((c) => {
+  let o;
+  if (typeof t == "string") {
+    const h = new N(c);
+    h.ofType(t), o = h;
+  } else
+    o = t;
+  const a = {}, u = (h) => {
+    const r = a[h.id];
+    return r ? Promise.resolve(r.controller) : st.getInstance(n).then((p) => new S(p, h, s));
+  };
+  c.events.subscribe(
+    "components:node-enter",
+    (h, { node: r }) => {
+      o.match(r) && u(r).then((p) => {
+        Promise.resolve(e(p)).then((l) => {
+          a[r.id] = {
+            dispose: l,
+            controller: p
+          };
+        });
+      });
+    }
+  ), c.events.subscribe(
+    "components:node-exit",
+    (h, { node: r }) => {
+      const p = a[r.id];
+      p && (p.dispose && p.dispose(), i.reuseController || (p.controller.dispose(), delete a[r.id]));
+    }
+  );
+});
+class ft {
+  constructor(t) {
+    this.aliases = /* @__PURE__ */ new Map(), this.components = /* @__PURE__ */ new Map(), this.logger = new O();
+    const { events: e } = t.get("$widget");
+    this.events = e;
+  }
+  getComponent(t) {
+    const e = this.aliases.get(t), s = this.components.get(e || t) || null;
+    return process.env.NODE_ENV !== "production" && (s || this.logger.warn(
+      e || t,
+      `Unable to resolve component: "${e || t}". You most likely forgot to register the required plugin for: ${e || t}.`
+    )), s;
+  }
+  registerComponent(t, e) {
+    return this.components.set(t, e), this.events.dispatch("component-resolver:resolve", t), () => {
+      this.components.delete(t);
+    };
+  }
+  registerResolver(t, e) {
+    return this.events.subscribe(
+      "component-resolver:resolve",
+      (s, i) => {
+        if (i === t) {
+          const c = this.getComponent(t);
+          e(c);
+        }
+      }
+    );
+  }
+  registerAlias(t, e) {
+    return this.aliases.set(t, e), this.events.dispatch("component-resolver:resolve", t), () => {
+      this.aliases.delete(t);
+    };
+  }
+}
+const it = "#____version____#", _ = class L extends q {
+  constructor(t, e = []) {
+    super(t, e, {
+      transformPluginSettings: (s, i, c) => {
+        const o = c.get("$settings");
+        return {
+          ...o.plugins && i ? o.plugins[i] || {} : {},
+          ...s
+        };
+      }
+    });
+  }
+  createImplementation(t) {
+    const e = super.createImplementation(t);
+    return e.bindings = t.bindings, e;
+  }
+  /**
+   * Performs navigation for widgets matching the specified selector by invoking a
+   * 'navigate' command.
+   * @param selector Widget selector matching the widget(s) to perform navigation on.
+   * @param route Route name.
+   * @param params Route params.
+   */
+  navigate(t, e, s) {
+    this.widgets.query(t).forEach((i) => i.invoke("navigate", { route: e, params: s }));
+  }
+  /**
+   * Creates a runtime based on provided configuration.
+   * @param configuration Runtime configuration.
+   */
+  static create(t = {}) {
+    const e = [B].concat(
+      t.configurationApiExtensions || []
+    );
+    return new L("humany", e);
+  }
+  /**
+   * Creates a widget runtime based on provided configuration and retains configuration handlers
+   * registered on global context. Use this factory to fully support the default embed script.
+   * Will return any existing widget runtime if available.
+   * @param configuration Runtime configuration.
+   * @param global Object to read configuration handlers from (default: window).
+   */
+  static createFromGlobal(t, e = {}) {
+    if (this.isRuntime(t))
+      return t.patch(e), t;
+    const s = [], i = t && t._c;
+    i && i.forEach(
+      (o) => s.push(o)
+    );
+    const c = this.create(e);
+    return c.container.register("$runtimecfg", s), c;
+  }
+  /**
+   * Determines whether the specified object is a valid widget runtime.
+   * @param obj Object to compare.
+   */
+  static isRuntime(t) {
+    return !!(t && typeof t == "object" && t.container && typeof t.container.get == "function" && t.container.get("$environment") === t && t.container.owner === t);
+  }
+};
+_.version = `${it} (${j})`;
+let vt = _;
+class bt extends z {
+  constructor() {
+    super(...arguments), this.bindings = [];
+  }
+}
+class gt extends Q {
+  constructor(t, e) {
+    super(t, e);
+  }
+}
+var ot = /* @__PURE__ */ ((n) => (n.open = "open", n.closed = "closed", n.hidden = "hidden", n))(ot || {});
+class yt extends F {
+  constructor(t) {
+    super(t);
+  }
+}
+export {
+  at as ActionResolver,
+  P as ActionsController,
+  I as ComponentNode,
+  S as ComponentNodeController,
+  st as ComponentPlatform,
+  N as ComponentQuery,
+  ft as ComponentResolver,
+  vt as Environment,
+  bt as Implementation,
+  gt as Plugin,
+  ot as WidgetRenderState,
+  yt as WidgetType,
+  dt as asDescriptor,
+  pt as bootstrap,
+  ut as componentConfigurationApi,
+  C as createChildren,
+  lt as createComponentModel,
+  G as createEventSubscriber,
+  mt as extendComponent,
+  W as findComponent,
+  x as findVisibleComponents,
+  k as traverseComponents,
+  it as version
+};