@telia-ace/widget-core 1.0.9 → 1.0.12

package/dist/index.js

@@ -1,1047 +1,646 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { createConfigurationApi } from "@webprovisions/platform";
-import { uuid, Logger } from "@telia-ace/widget-utilities";
-class ActionResolver {
-  constructor(container) {
-    const { events } = container.get("$widget");
-    this.events = events.createChild(this);
-  }
-  action(target, action, value) {
-    this.events.dispatch("data:action", { action, value, target }, { bubbles: true });
-  }
-  subscribe(origin, fn) {
-    return this.events.subscribe("data:action", (e, { action, value, target }) => origin === target && fn(origin, action, value));
+var M = Object.defineProperty, V = Object.defineProperties;
+var _ = Object.getOwnPropertyDescriptors;
+var I = Object.getOwnPropertySymbols;
+var z = Object.prototype.hasOwnProperty, Q = Object.prototype.propertyIsEnumerable;
+var L = (n, t, e) => t in n ? M(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, S = (n, t) => {
+  for (var e in t || (t = {}))
+    z.call(t, e) && L(n, e, t[e]);
+  if (I)
+    for (var e of I(t))
+      Q.call(t, e) && L(n, e, t[e]);
+  return n;
+}, j = (n, t) => V(n, _(t));
+import { createConfigurationApi as q } from "@webprovisions/platform";
+import { uuid as E, Logger as O } from "@telia-ace/widget-utilities";
+class ct {
+  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: r, value: c, target: o }) => t === o && e(t, r, c));
   }
 }
-const createEventSubscriber = (events) => {
-  const subs = [];
-  const subscribe = (type, listener) => {
-    subs.push(events.subscribe(type, listener));
-  };
+const K = (n) => {
+  const t = [];
   return [
-    subscribe,
+    (s, r) => {
+      t.push(n.subscribe(s, r));
+    },
     () => {
-      subs.forEach((sub) => {
-        sub();
+      t.forEach((s) => {
+        s();
       });
     }
   ];
 };
-class ComponentQuery {
-  constructor(platform, rules = []) {
-    this.platform = platform;
-    this.rules = rules;
-  }
-  match(node) {
-    return this.rules.every((rule) => {
-      if (rule.id && rule.id !== node.id) {
-        return false;
-      }
-      if (rule.type && rule.type !== node.type) {
-        return false;
-      }
-      return true;
-    });
+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(type) {
-    this.rules.push({ type });
-    return this;
+  ofType(t) {
+    return this.rules.push({ type: t }), this;
   }
-  withId(id) {
-    this.rules.push({ id });
-    return this;
+  withId(t) {
+    return this.rules.push({ id: t }), this;
   }
   select() {
-    return new AbstractComponentController(this.platform, this);
+    return new U(this.platform, this);
   }
 }
-class ComponentNodeController {
-  constructor(platform, node, ns) {
-    this.platform = platform;
-    this.node = node;
-    this.actions = new ActionsController(platform, new ComponentQuery(platform).withId(node.id), ns);
-    const [subscribe, unsubscribe] = createEventSubscriber(this.platform.events);
-    this.subscribe = subscribe;
-    this.unsubscribe = unsubscribe;
-  }
-  properties(updated) {
-    if (updated) {
-      this.node.touchProperties((properties) => updated(properties));
-    }
-    return this.node.attributes.properties;
-  }
-  context(updated) {
-    if (updated) {
-      this.subscribe("components:context-changed", (event, { node }) => {
-        if (node === this.node) {
-          updated(this.node.attributes.context);
-        }
-      });
-    }
-    return this.node.attributes.context;
-  }
-  layout(updated) {
-    if (updated) {
-      this.subscribe("components:layout-changed", (event, { node }) => {
-        if (node === this.node) {
-          updated(this.node.attributes.layout);
-        }
-      });
-    }
-    return this.node.attributes.layout;
+class $ {
+  constructor(t, e, s) {
+    this.platform = t, this.node = e, this.actions = new k(t, new N(t).withId(e.id), s);
+    const [r, c] = K(this.platform.events);
+    this.subscribe = r, 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(properties, options) {
-    this.node.writeProperties(properties, options);
+  writeProperties(t, e) {
+    this.node.writeProperties(t, e);
   }
-  writeContext(context, options) {
-    this.node.writeProperties(context, options);
+  writeContext(t, e) {
+    this.node.writeProperties(t, e);
   }
-  writeLayout(layout, options) {
-    this.node.writeLayout(layout, options);
+  writeLayout(t, e) {
+    this.node.writeLayout(t, e);
   }
   dispose() {
-    this.unsubscribe();
-    this.actions.dispose();
+    this.unsubscribe(), this.actions.dispose();
   }
 }
-class AbstractComponentController {
-  constructor(platform, target, clearOnDispose = true) {
-    this.platform = platform;
-    this.target = target;
-    this.clearOnDispose = clearOnDispose;
-    this.removes = [];
-    this.actions = new ActionsController(this.platform, this.target);
-  }
-  writeProperties(properties, options) {
+class U {
+  constructor(t, e, s = !0) {
+    this.platform = t, this.target = e, this.clearOnDispose = s, this.removes = [], this.actions = new k(this.platform, this.target);
+  }
+  writeProperties(t, e) {
     this.removes.push(this.platform.write({
-      options,
-      attributes: { properties },
+      options: e,
+      attributes: { properties: t },
       target: this.target,
       removable: this.clearOnDispose
     }));
   }
-  writeContext(context, options) {
+  writeContext(t, e) {
     this.removes.push(this.platform.write({
-      options,
-      attributes: { context },
+      options: e,
+      attributes: { context: t },
       target: this.target,
       removable: this.clearOnDispose
     }));
   }
-  writeLayout(layout, options) {
+  writeLayout(t, e) {
     this.removes.push(this.platform.write({
-      options,
-      attributes: { layout },
+      options: e,
+      attributes: { layout: t },
       target: this.target,
       removable: this.clearOnDispose
     }));
   }
   dispose() {
-    this.removes.forEach((remove) => {
-      remove();
-    });
-    this.actions.dispose();
+    this.removes.forEach((t) => {
+      t();
+    }), this.actions.dispose();
   }
 }
-const executeActionListeners = (listeners, data, controller) => {
-  const stack = listeners.concat();
-  const dispatch = (data2, globalOptions, controller2) => {
-    let cancelled = true;
-    if (stack.length) {
-      const handler = stack.shift();
-      const next = (data3, options) => {
-        cancelled = false;
-        return dispatch(data3, Object.assign({}, globalOptions, options), controller2);
-      };
-      return Promise.resolve(handler(data2, next, controller2)).then((result) => __spreadProps(__spreadValues({}, result), {
-        cancelled
+const Y = (n, t, e) => {
+  const s = n.concat(), r = (c, o, a) => {
+    let u = !0;
+    if (s.length) {
+      const h = s.shift(), i = (p, l) => (u = !1, r(p, Object.assign({}, o, l), a));
+      return Promise.resolve(h(c, i, a)).then((p) => j(S({}, p), {
+        cancelled: u
       }));
     }
-    return Promise.resolve({ data: data2, cancelled: false, options: globalOptions });
+    return Promise.resolve({ data: c, cancelled: !1, options: o });
   };
-  return dispatch(data, {}, controller);
+  return r(t, {}, e);
 };
-class ActionsController {
-  constructor(platform, target, ns) {
-    this.platform = platform;
-    this.target = target;
-    this.ns = ns;
-    this.subscriptions = [];
-    this.create = this.create.bind(this);
-  }
-  create(key, fn = () => {
+class k {
+  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 handler = {
-      key,
-      fn,
+    const s = {
+      key: t,
+      fn: e,
       target: this.target,
       ns: this.ns
     };
-    this.platform.actionsState.handlers.push(handler);
-    const subscription = () => {
-      const index = this.platform.actionsState.handlers.indexOf(handler);
-      if (index > -1) {
-        this.platform.actionsState.handlers.splice(index, 1);
-      }
+    this.platform.actionsState.handlers.push(s);
+    const r = () => {
+      const c = this.platform.actionsState.handlers.indexOf(s);
+      c > -1 && this.platform.actionsState.handlers.splice(c, 1);
     };
-    this.subscriptions.push(subscription);
-    return subscription;
-  }
-  dispatch(key, data) {
-    const instances = this.platform.nodes.all.concat(this.platform.nodes.detached);
-    const output = {};
-    const handlers = this.platform.actionsState.handlers.filter((handler) => handler.key === key && (!handler.ns || !this.ns || handler.ns === this.ns));
-    return Promise.all(handlers.map((handler) => {
-      const matchedInstances = instances.filter((instance) => handler.target.match(instance) && this.target.match(instance));
-      const watchers = this.platform.actionsState.watchers.filter((watcher) => {
-        return watcher.key === key && (!watcher.ns || !this.ns || watcher.ns === this.ns) && matchedInstances.some((instance) => watcher.target.match(instance));
-      }).map((watcher) => watcher.fn);
-      return Promise.all(matchedInstances.map((node) => {
-        const controller = new ComponentNodeController(this.platform, node, this.ns);
-        return executeActionListeners(watchers, data, controller).then((input) => {
-          const { data: data2 = {}, options, cancelled } = input;
-          return Promise.resolve(cancelled ? {} : handler.fn(data2, options, controller)).then((handlerResponse) => {
-            output[node.id] = handlerResponse;
+    return this.subscriptions.push(r), r;
+  }
+  dispatch(t, e) {
+    const s = this.platform.nodes.all.concat(this.platform.nodes.detached), r = {}, 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((i) => h.target.match(i))).map((h) => h.fn);
+      return Promise.all(a.map((h) => {
+        const i = new $(this.platform, h, this.ns);
+        return Y(u, e, i).then((p) => {
+          const { data: l = {}, options: d, cancelled: v } = p;
+          return Promise.resolve(v ? {} : o.fn(l, d, i)).then((g) => {
+            r[h.id] = g;
           });
         });
       }));
-    })).then(() => output);
-  }
-  watch(key, fn) {
-    let parsedKey = key;
-    let parsedNs = this.ns;
-    const sections = key.split(".");
-    if (sections.length > 1) {
-      parsedNs = sections[0];
-      parsedKey = sections.splice(1).join(".");
-    }
-    const watcher = {
-      fn,
+    })).then(() => r);
+  }
+  watch(t, e) {
+    let s = t, r = this.ns;
+    const c = t.split(".");
+    c.length > 1 && (r = c[0], s = c.splice(1).join("."));
+    const o = {
+      fn: e,
       target: this.target,
-      key: parsedKey,
-      ns: parsedNs
+      key: s,
+      ns: r
     };
-    this.platform.actionsState.watchers.push(watcher);
-    const subscription = () => {
-      const index = this.platform.actionsState.watchers.indexOf(watcher);
-      if (index > -1) {
-        this.platform.actionsState.watchers.splice(index, 1);
-      }
+    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);
     };
-    this.subscriptions.push(subscription);
-    return subscription;
+    return this.subscriptions.push(a), a;
   }
   dispose() {
-    this.subscriptions.forEach((unsubscribe) => unsubscribe());
+    this.subscriptions.forEach((t) => t());
   }
 }
-var componentConfigurationApi = createConfigurationApi((builder) => {
-  builder.createCommand("components", (context) => (config) => {
-    context.events.subscribeOnce("components:platform-created", (event, { platform }) => {
-      if (config.handlers) {
-        config.handlers.forEach(([key, handler]) => {
-          platform.addComponentHandler(key, handler);
-        });
-      }
+const ht = q((n) => {
+  n.createCommand("components", (t) => (e) => {
+    t.events.subscribeOnce("components:platform-created", (s, { platform: r }) => {
+      e.handlers && e.handlers.forEach(([c, o]) => {
+        r.addComponentHandler(c, o);
+      });
     });
   });
 });
-class ComponentNode {
-  constructor(events, type) {
-    this.events = events;
-    this.tags = [];
-    this.children = {};
-    this.changesets = [];
-    this.mountCount = 0;
-    this.id = uuid();
-    this.type = type;
-    this.attributes = {
+class H {
+  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 });
+    }, this.writeLayout({ size: "full", indent: 0 });
   }
-  mount(viewOutletContainer, element) {
-    let mountedNodes = viewOutletContainer.get("mounted-nodes");
-    if (!mountedNodes) {
-      mountedNodes = /* @__PURE__ */ new Map();
-      viewOutletContainer.register("mounted-nodes", mountedNodes);
-    }
-    if (mountedNodes.has(this)) {
-      return () => {
-      };
-    }
-    this.events.dispatch("components:node-mounted", { node: this });
-    if (this.mountCount === 0) {
-      this.mountCount = this.mountCount + 1;
-      this.events.dispatch("components:node-enter", { node: this });
-    }
-    return () => {
-      mountedNodes.delete(this);
-      this.events.dispatch("components:node-unmounted", { node: this });
-      this.mountCount = this.mountCount - 1;
-      if (this.mountCount === 0) {
-        this.events.dispatch("components:node-exit", { node: this });
-      }
-    };
+  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(node, branch = "default") {
-    if (node.parent) {
-      if (node.parent === this) {
+  appendChild(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
         return;
-      }
-      node.parent.removeChild(node);
+      t.parent.removeChild(t);
     }
-    node.parent = this;
-    if (!this.children[branch]) {
-      this.children[branch] = [];
-    }
-    this.children[branch].push(node);
-    this.events.dispatch("components:node-appended", { node });
+    t.parent = this, this.children[e] || (this.children[e] = []), this.children[e].push(t), this.events.dispatch("components:node-appended", { node: t });
   }
-  prependChild(node, branch = "default") {
-    if (node.parent) {
-      if (node.parent === this) {
+  prependChild(t, e = "default") {
+    if (t.parent) {
+      if (t.parent === this)
         return;
-      }
-      node.parent.removeChild(node);
-    }
-    node.parent = this;
-    if (!this.children[branch]) {
-      this.children[branch] = [];
+      t.parent.removeChild(t);
     }
-    this.children[branch].unshift(node);
-    this.events.dispatch("components:node-appended", { node });
-  }
-  touchProperties(properties, options = {}, removable) {
-    const attributes = { properties };
-    const changeset = [attributes, options];
-    this.changesets.push(changeset);
-    this.events.dispatch("components:set-properties", { node: this });
-    return () => {
-      if (removable) {
-        const indexToRemove = this.changesets.indexOf(changeset);
-        if (indexToRemove > -1) {
-          this.changesets.splice(indexToRemove, 1);
-          this.events.dispatch("components:set-properties", { node: this });
-        }
+    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(properties, options = {}, removable) {
-    const attributes = { properties };
-    const changeset = [attributes, options];
-    this.changesets.push(changeset);
-    this.events.dispatch("components:set-properties", { node: this });
-    return () => {
-      if (removable) {
-        const indexToRemove = this.changesets.indexOf(changeset);
-        if (indexToRemove > -1) {
-          this.changesets.splice(indexToRemove, 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(layout, options = {}, removable) {
-    const attributes = { layout };
-    const changeset = [attributes, options];
-    this.changesets.push(changeset);
-    this.events.dispatch("components:set-layout", { node: this });
-    return () => {
-      if (!removable) {
+  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 indexToRemove = this.changesets.indexOf(changeset);
-      if (indexToRemove > -1) {
-        this.changesets.splice(indexToRemove, 1);
-        this.events.dispatch("components:set-layout", { node: this });
-      }
+      const o = this.changesets.indexOf(c);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-layout", { node: this }));
     };
   }
-  writeContext(context, options = {}, removable) {
-    const attributes = { context };
-    const changeset = [attributes, options];
-    this.changesets.push(changeset);
-    this.events.dispatch("components:set-context", { node: this });
-    return () => {
-      if (!removable) {
+  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 indexToRemove = this.changesets.indexOf(changeset);
-      if (indexToRemove > -1) {
-        this.changesets.splice(indexToRemove, 1);
-        this.events.dispatch("components:set-context", { node: this });
-      }
+      const o = this.changesets.indexOf(c);
+      o > -1 && (this.changesets.splice(o, 1), this.events.dispatch("components:set-context", { node: this }));
     };
   }
-  getChildren(branch = "default") {
-    const children = this.children[branch] || [];
-    return children.reduce((acc, node, i) => {
-      const { order: index = i } = node.attributes.layout;
-      if (!acc[index]) {
-        acc[index] = node;
-      } else {
-        acc.splice(index, 0, node);
-      }
-      return acc;
-    }, Array(children.length));
+  getChildren(t = "default") {
+    const e = this.children[t] || [];
+    return e.reduce((s, r, c) => {
+      const { order: o = c } = r.attributes.layout;
+      return s[o] ? s.splice(o, 0, r) : s[o] = r, s;
+    }, Array(e.length));
   }
   remove() {
-    if (this.parent) {
-      this.parent.removeChild(this);
-    }
+    this.parent && this.parent.removeChild(this);
   }
-  removeChild(node) {
-    Object.keys(this.children).forEach((branch) => {
-      const children = this.children[branch];
-      const indexToRemove = children.indexOf(node);
-      if (indexToRemove > -1) {
-        children.splice(indexToRemove, 1);
-        this.events.dispatch("components:node-removed", { node, parentNode: this });
-      }
-    });
-    delete node.parent;
+  removeChild(t) {
+    Object.keys(this.children).forEach((e) => {
+      const s = this.children[e], r = s.indexOf(t);
+      r > -1 && (s.splice(r, 1), this.events.dispatch("components:node-removed", { node: t, parentNode: this }));
+    }), delete t.parent;
   }
 }
-const traverseComponentsRecursive = (nodes, switches, fn) => {
-  for (let i = 0, y = nodes.length; i < y; i++) {
-    if (fn(nodes[i]) === true) {
-      break;
-    }
-    const branch = switches[nodes[i].id] || "default";
-    const children = nodes[i].getChildren(branch);
-    traverseComponentsRecursive(children, switches, fn);
-  }
-};
-const traverseComponents = (root, switches, fn) => {
-  if (fn(root) !== true) {
-    const branch = switches[root.id] || "default";
-    const children = root.children[branch];
-    traverseComponentsRecursive(children, switches, fn);
-  }
+const B = (n, t, e) => {
+  for (let s = 0, r = n.length; s < r && e(n[s]) !== !0; s++) {
+    const c = t[n[s].id] || "default", o = n[s].getChildren(c);
+    B(o, t, e);
+  }
+}, P = (n, t, e) => {
+  if (e(n) !== !0) {
+    const s = t[n.id] || "default", r = n.children[s];
+    B(r, t, e);
+  }
+}, x = (n, t) => {
+  const e = [];
+  return P(n, t, (s) => {
+    e.push(s);
+  }), e;
+}, F = (n, t, e) => {
+  let s;
+  return P(n, t, (r) => {
+    if (e(r))
+      return s = r, !0;
+  }), s;
 };
-const findVisibleComponents = (root, switches) => {
-  const nodes = [];
-  traverseComponents(root, switches, (node) => {
-    nodes.push(node);
-  });
-  return nodes;
-};
-const findComponent = (root, switches, fn) => {
-  let matched;
-  traverseComponents(root, switches, (node) => {
-    if (fn(node)) {
-      matched = node;
-      return true;
-    }
-  });
-  return matched;
-};
-class ComponentNodeCollection {
-  constructor(root, switches, events) {
-    this.root = root;
-    this.switches = switches;
-    this.all = [];
-    this.visible = [];
-    this.detached = [];
-    events.subscribe("components:node-appended", (event, data) => {
-      this.all.push(data.node);
-      this.visible = findVisibleComponents(root, switches);
-    });
-    events.subscribe("components:node-removed", (event, data) => {
-      let indexToRemove = this.all.indexOf(data.node);
-      if (indexToRemove > -1) {
-        this.all.splice(indexToRemove, 1);
-      }
-      indexToRemove = this.visible.indexOf(data.node);
-      if (indexToRemove > -1) {
-        this.visible.splice(indexToRemove, 1);
-      }
-      this.visible = findVisibleComponents(root, switches);
-    });
-    events.subscribe("components:node-switched", (event, data) => {
-      this.visible = findVisibleComponents(root, switches);
+class G {
+  constructor(t, e, s) {
+    this.root = t, this.switches = e, this.all = [], this.visible = [], this.detached = [], s.subscribe("components:node-appended", (r, c) => {
+      this.all.push(c.node), this.visible = x(t, e);
+    }), s.subscribe("components:node-removed", (r, 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", (r, c) => {
+      this.visible = x(t, e);
     });
   }
-  query(query = {}) {
-    const nodes = [];
-    traverseComponents(this.root, this.switches, (node) => {
-      const match = Object.keys(query).every((member) => {
-        return query[member] === node[member];
-      });
-      if (match) {
-        nodes.push(node);
-      }
-    });
-    return nodes;
+  query(t = {}) {
+    const e = [];
+    return P(this.root, this.switches, (s) => {
+      Object.keys(t).every((c) => t[c] === s[c]) && e.push(s);
+    }), e;
   }
-  get(id) {
-    return findComponent(this.root, this.switches, (node) => node.id === id) || this.detached.find((node) => node.id === id);
+  get(t) {
+    return F(this.root, this.switches, (e) => e.id === t) || this.detached.find((e) => e.id === t);
   }
 }
-class CustomComponentHandler {
+class J {
   constructor() {
     this.handlers = /* @__PURE__ */ new Map();
   }
-  add(name, fn) {
-    this.handlers.set(name, fn);
+  add(t, e) {
+    this.handlers.set(t, e);
   }
-  get(name) {
-    return this.handlers.get(name);
+  get(t) {
+    return this.handlers.get(t);
   }
 }
-const calculateNodeIndex = (node) => {
-  let currentNode = node;
-  let index = 0;
-  while (currentNode.parent) {
-    index = index + 1;
-    currentNode = currentNode.parent;
-  }
-  return index;
-};
-const sortQueue = (queue) => {
-  const mapped = queue.map(([node, options]) => {
-    return [calculateNodeIndex(node), node, options];
-  });
-  return mapped.sort(([a], [b]) => a - b).map(([, node, options]) => {
-    return [node, options];
-  });
-};
-const isObject = (item) => {
-  return item && typeof item === "object" && !Array.isArray(item);
-};
-const mergeDeep = (target, ...sources) => {
-  if (!sources.length)
-    return target;
-  const source = sources.shift();
-  if (isObject(target) && isObject(source)) {
-    for (const key in source) {
-      if (isObject(source[key])) {
-        if (!target[key])
-          Object.assign(target, { [key]: {} });
-        mergeDeep(target[key], source[key]);
-      } else {
-        Object.assign(target, { [key]: source[key] });
-      }
-    }
-  }
-  return mergeDeep(target, ...sources);
-};
-const matchesBreakpoint = (b1, b2) => {
-  if (!b1 || b1 === "all") {
-    return true;
-  }
-  return b1.some((b12) => b2.indexOf(b12) > -1);
-};
-const createStateProcessor = (platform, callback) => {
-  let nodeQueue = [];
-  let optionsQueue = [];
-  let timeout;
-  const flush = () => {
-    const processHistory = /* @__PURE__ */ new Map();
-    const sortedQueue = sortQueue(nodeQueue.map((node, i) => [node, optionsQueue[i]]));
-    const processNode = (node, options) => {
-      var _a;
-      const history = processHistory.get(node) || {};
-      const processContext = options.context && !history.context;
-      const processProperties = options.properties && !history.properties;
-      const processLayout = options.layout && !history.layout;
-      processHistory.set(node, {
-        context: history.context || processContext,
-        properties: history.properties || processProperties,
-        layout: history.layout || processLayout
-      });
-      if (processProperties) {
-        node.attributes.properties = {};
-      }
-      if (processLayout) {
-        node.attributes.layout = {};
-      }
-      if (processContext) {
-        node.attributes.context = mergeDeep({}, (_a = node.parent) == null ? void 0 : _a.attributes.context);
-      }
-      const propertyResolvers = [];
-      const layoutResolvers = [];
-      const contextResolvers = [];
-      node.changesets.forEach((changeset) => {
-        const [change, options2] = changeset;
-        if (matchesBreakpoint(options2.breakpoints, platform.breakpoints)) {
-          if (processProperties) {
-            if (typeof change.properties === "function") {
-              propertyResolvers.push(change.properties);
-            } else {
-              mergeDeep(node.attributes.properties, change.properties);
-            }
-          }
-          if (processLayout) {
-            if (typeof change.layout === "function") {
-              layoutResolvers.push(change.layout);
-            } else {
-              mergeDeep(node.attributes.layout, change.layout);
-            }
-          }
-          if (processContext) {
-            if (typeof change.context === "function") {
-              contextResolvers.push(change.context);
-            } else {
-              mergeDeep(node.attributes.context, change.context);
-            }
-          }
-        }
-      });
-      propertyResolvers.forEach((resolver) => {
-        mergeDeep(node.attributes.properties, resolver(node.attributes.properties));
-      });
-      layoutResolvers.forEach((resolver) => {
-        mergeDeep(node.attributes.layout, resolver(node.attributes.layout));
-      });
-      contextResolvers.forEach((resolver) => {
-        mergeDeep(node.attributes.context, resolver(node.attributes.context));
-      });
-      if (processContext || options.recursive) {
-        const branch = platform.getBranch(node);
-        const childOptions = options.recursive ? options : {
-          context: !!processContext
+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 && typeof n == "object" && !Array.isArray(n), b = (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]: {} }), b(n[s], e[s])) : Object.assign(n, { [s]: e[s] });
+  return b(n, ...t);
+}, W = (n, t) => !n || n === "all" ? !0 : n.some((e) => t.indexOf(e) > -1), tt = (n, t) => {
+  let e = [], s = [], r;
+  const c = () => {
+    process.env.NODE_ENV !== "production" && console.time("state-processor.flush");
+    const a = /* @__PURE__ */ new Map(), u = Z(e.map((i, p) => [i, s[p]])), h = (i, p) => {
+      var T;
+      const l = a.get(i) || {}, d = p.context && !l.context, v = p.properties && !l.properties, g = p.layout && !l.layout;
+      a.set(i, {
+        context: l.context || d,
+        properties: l.properties || v,
+        layout: l.layout || g
+      }), v && (i.attributes.properties = {}), g && (i.attributes.layout = {}), d && (i.attributes.context = b({}, (T = i.parent) == null ? void 0 : T.attributes.context));
+      const R = [], A = [], D = [];
+      if (i.changesets.forEach((m) => {
+        const [f, y] = m;
+        W(y.breakpoints, n.breakpoints) && (v && (typeof f.properties == "function" ? R.push(f.properties) : b(i.attributes.properties, f.properties)), g && (typeof f.layout == "function" ? A.push(f.layout) : b(i.attributes.layout, f.layout)), d && (typeof f.context == "function" ? D.push(f.context) : b(i.attributes.context, f.context)));
+      }), R.forEach((m) => {
+        b(i.attributes.properties, m(i.attributes.properties));
+      }), A.forEach((m) => {
+        b(i.attributes.layout, m(i.attributes.layout));
+      }), D.forEach((m) => {
+        b(i.attributes.context, m(i.attributes.context));
+      }), d || p.recursive) {
+        const m = n.getBranch(i), f = p.recursive ? p : {
+          context: !!d
         };
-        node.getChildren(branch).forEach((child) => {
-          processNode(child, childOptions);
+        i.getChildren(m).forEach((y) => {
+          h(y, f);
         });
       }
     };
-    sortedQueue.forEach(([node, options]) => {
-      processNode(node, options);
-    });
-    nodeQueue = [];
-    optionsQueue = [];
-    callback(processHistory);
+    process.env.NODE_ENV !== "production" && console.timeEnd("state-processor.flush"), u.forEach(([i, p]) => {
+      h(i, p);
+    }), e = [], s = [], t(a);
+  }, o = () => {
+    clearTimeout(r), r = setTimeout(c, 0);
   };
-  const schedule = () => {
-    clearTimeout(timeout);
-    timeout = setTimeout(flush, 0);
-  };
-  return (node, options) => {
-    const index = nodeQueue.indexOf(node);
-    if (index > -1) {
-      const summary = optionsQueue[index];
-      if (options.context) {
-        summary.context = true;
-      }
-      if (options.properties) {
-        summary.properties = true;
-      }
-      if (options.layout) {
-        summary.layout = true;
-      }
-      if (options.recursive) {
-        summary.recursive = true;
-      }
-      return schedule();
+  return (a, u) => {
+    const h = e.indexOf(a);
+    if (h > -1) {
+      const i = s[h];
+      return u.context && (i.context = !0), u.properties && (i.properties = !0), u.layout && (i.layout = !0), u.recursive && (i.recursive = !0), o();
     }
-    nodeQueue.push(node);
-    optionsQueue.push(options);
-    return schedule();
+    return e.push(a), s.push(u), o();
   };
 };
-class ComponentPlatform {
-  constructor(widget, providers = {}) {
-    this.providers = providers;
-    this.breakpoints = [];
-    this.actionsState = { handlers: [], watchers: [] };
-    this.switches = {};
-    this.changesets = [];
-    this.subscriptions = [];
-    this.customComponentHandler = new CustomComponentHandler();
-    this.events = widget.events.createChild(this);
-    const root = new ComponentNode(this.events, "root");
-    root.name = `root-${widget.name}`;
-    this.nodes = new ComponentNodeCollection(root, this.switches, this.events);
-    const processNode = this.processNode = createStateProcessor(this, (report) => {
-      const nodes = Array.from(report.keys());
-      nodes.forEach((node) => {
-        const options = report.get(node);
-        if (node.parent && node.parent.type === "root") {
-          this.events.dispatch("components:root-children-changed", { node });
-        }
-        if (options == null ? void 0 : options.context) {
-          this.events.dispatch("components:context-changed", { node });
-        }
-        if (options == null ? void 0 : options.properties) {
-          this.events.dispatch("components:properties-changed", { node });
-        }
-        if (options == null ? void 0 : options.layout) {
-          this.events.dispatch("components:layout-changed", { node });
-        }
-      });
-      this.events.dispatch("components:component-model-initialized", {}, { bubbles: true });
+class et {
+  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 H(this.events, "root");
+    s.name = `root-${t.name}`, this.nodes = new G(s, this.switches, this.events);
+    const r = this.processNode = tt(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(providers).map((key) => {
-      const provider = providers[key];
-      return provider.load(this);
-    }));
-    this.subscriptions.push(this.events.subscribe("components:node-appended", (event, data) => {
-      const { node } = data;
-      this.changesets.forEach((record) => {
-        const { changeset, target, removes } = record;
-        const [change, options] = changeset;
-        if (target.match(data.node)) {
-          if (change.properties) {
-            removes.push(node.writeProperties(change.properties, options));
-          }
-          if (change.context) {
-            removes.push(node.writeContext(change.context, options));
-          }
-          if (change.layout) {
-            removes.push(node.writeLayout(change.layout, options));
-          }
-        }
+    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: i, removes: p } = u, [l, d] = h;
+        i.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", (event, data) => {
-      processNode(data.node, { properties: true, context: true });
-    }));
-    this.subscriptions.push(this.events.subscribe("components:set-properties", (event, data) => {
-      processNode(data.node, { properties: true });
-    }));
-    this.subscriptions.push(this.events.subscribe("components:set-context", (event, data) => {
-      processNode(data.node, { properties: true, context: true });
-    }));
-    this.subscriptions.push(this.events.subscribe("components:set-indent", (event, data) => {
-      processNode(data.node, { layout: true });
-    }));
-    this.subscriptions.push(this.events.subscribe("components:set-layout", (event, data) => {
-      processNode(data.node, { layout: true });
-    }));
-    this.subscriptions.push(this.events.subscribe("components:node-switched", (event, { node, branch }) => {
-      processNode(node, {
-        layout: true,
-        recursive: true,
-        properties: true,
-        context: true
+    })), this.subscriptions.push(this.events.subscribe("components:node-appended", (c, o) => {
+      r(o.node, { properties: !0, context: !0 });
+    })), this.subscriptions.push(this.events.subscribe("components:set-properties", (c, o) => {
+      r(o.node, { properties: !0 });
+    })), this.subscriptions.push(this.events.subscribe("components:set-context", (c, o) => {
+      r(o.node, { properties: !0, context: !0 });
+    })), this.subscriptions.push(this.events.subscribe("components:set-indent", (c, o) => {
+      r(o.node, { layout: !0 });
+    })), this.subscriptions.push(this.events.subscribe("components:set-layout", (c, o) => {
+      r(o.node, { layout: !0 });
+    })), this.subscriptions.push(this.events.subscribe("components:node-switched", (c, { node: o, branch: a }) => {
+      r(o, {
+        layout: !0,
+        recursive: !0,
+        properties: !0,
+        context: !0
       });
+    })), this.subscriptions.push(this.events.subscribe("components:node-removed", (c, { parentNode: o }) => {
+      r(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
     }));
-    this.subscriptions.push(this.events.subscribe("components:node-removed", (event, { parentNode }) => {
-      processNode(parentNode, { properties: true });
+  }
+  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
     }));
-    if (this.events.parent) {
-      this.events.parent.dispatch("components:platform-created", { platform: this });
-    }
   }
-  static getInstance(container) {
-    return container.getAsync("components");
-  }
-  addBreakpoint(name) {
-    if (this.breakpoints.indexOf(name) === -1) {
-      this.breakpoints.push(name);
-      this.processNode(this.nodes.root, {
-        context: true,
-        properties: true,
-        layout: true,
-        recursive: true
-      });
-    }
+  setSwitch(t, e) {
+    this.switches[t.id] = e, this.events.dispatch("components:node-switched", { node: t, branch: e });
   }
-  removeBreakpoint(name) {
-    const indexToRemove = this.breakpoints.indexOf(name);
-    if (indexToRemove > -1) {
-      this.breakpoints.splice(indexToRemove, 1);
-      this.processNode(this.nodes.root, {
-        context: true,
-        properties: true,
-        layout: true,
-        recursive: true
-      });
-    }
+  getBranch(t) {
+    return this.switches[t.id];
   }
-  setSwitch(node, branch) {
-    this.switches[node.id] = branch;
-    this.events.dispatch("components:node-switched", { node, branch });
+  createNode(t, e = {}) {
+    const s = new H(this.events, t);
+    return e.detached && this.nodes.detached.push(s), s;
   }
-  getBranch(node) {
-    return this.switches[node.id];
+  components() {
+    return new N(this);
   }
-  createNode(type, options = {}) {
-    const node = new ComponentNode(this.events, type);
-    if (options.detached) {
-      this.nodes.detached.push(node);
-    }
-    return node;
+  actions(t, e) {
+    return new k(this, t, e);
   }
-  components() {
-    return new ComponentQuery(this);
-  }
-  actions(target, ns) {
-    return new ActionsController(this, target, ns);
-  }
-  write(data) {
-    const { provider: providerName, target, attributes, options = {}, removable } = data;
-    const key = data.key || uuid();
-    const changeset = [attributes, options];
-    const record = { changeset, target, removes: [] };
-    if (providerName) {
-      const provider = this.providers[providerName];
-      provider.write(key, target, attributes, options);
-      record.removes.push(() => {
-        provider.remove(key);
+  write(t) {
+    const { provider: e, target: s, attributes: r, options: c = {}, removable: o } = t, a = t.key || E(), h = { changeset: [r, c], target: s, removes: [] };
+    if (e) {
+      const i = this.providers[e];
+      i.write(a, s, r, c), h.removes.push(() => {
+        i.remove(a);
       });
     }
-    this.changesets.push(record);
-    this.nodes.all.forEach((node) => {
-      if (target.match(node)) {
-        let remove = () => {
+    return this.changesets.push(h), this.nodes.all.forEach((i) => {
+      if (s.match(i)) {
+        let p = () => {
         };
-        if (attributes.properties) {
-          remove = node.writeProperties(attributes.properties, options, removable);
-        }
-        if (attributes.context) {
-          remove = node.writeContext(attributes.context, options, removable);
-        }
-        if (attributes.layout) {
-          remove = node.writeContext(attributes.layout, options, removable);
-        }
-        record.removes.push(remove);
+        r.properties && (p = i.writeProperties(r.properties, c, o)), r.context && (p = i.writeContext(r.context, c, o)), r.layout && (p = i.writeContext(r.layout, c, o)), h.removes.push(p);
       }
-    });
-    return () => {
-      if (removable) {
-        record.removes.forEach((remove) => remove());
-        const indexToRemove = this.changesets.indexOf(record);
-        if (indexToRemove > -1) {
-          this.changesets.splice(indexToRemove, 1);
-        }
+    }), () => {
+      if (o) {
+        h.removes.forEach((p) => p());
+        const i = this.changesets.indexOf(h);
+        i > -1 && this.changesets.splice(i, 1);
       }
     };
   }
-  addComponentHandler(definitionType, fn) {
-    this.customComponentHandler.add(definitionType, fn);
+  addComponentHandler(t, e) {
+    this.customComponentHandler.add(t, e);
   }
-  getComponentHandler(definitionType) {
-    return this.customComponentHandler.get(definitionType);
+  getComponentHandler(t) {
+    return this.customComponentHandler.get(t);
   }
   dispose() {
-    this.subscriptions.forEach((sub) => sub());
+    this.subscriptions.forEach((t) => t());
   }
 }
-const normalizeReference = (reference) => {
-  if (Array.isArray(reference)) {
-    const [definitionId, ...overrides] = reference;
+const st = (n) => {
+  if (Array.isArray(n)) {
+    const [t, ...e] = n;
     return {
-      definitionId,
-      overrides
+      definitionId: t,
+      overrides: e
     };
   }
   return {
-    definitionId: reference,
+    definitionId: n,
     overrides: []
   };
-};
-const createChildren = (platform, node, references, definitions, views, branch) => {
-  references.forEach((ref) => {
-    const childRef = normalizeReference(ref);
-    const childDef = definitions[childRef.definitionId];
-    if (childRef.definitionId === "view") {
-      const viewNode = platform.createNode("view");
-      viewNode.name = "view";
-      Object.keys(views).forEach((key) => {
-        const viewDef = views[key];
-        createChildren(platform, viewNode, [viewDef.entry], definitions, views, key);
+}, C = (n, t, e, s, r, c) => {
+  e.forEach((o) => {
+    const a = st(o), u = s[a.definitionId];
+    if (a.definitionId === "view") {
+      const h = n.createNode("view");
+      h.name = "view", Object.keys(r).forEach((i) => {
+        const p = r[i];
+        C(n, h, [p.entry], s, r, i);
+      }), t.appendChild(h), a.overrides.forEach((i) => {
+        i.properties && h.writeProperties(i.properties, {
+          breakpoints: i.breakpoints
+        }), i.context && h.writeContext(i.context, { breakpoints: i.breakpoints }), i.layout && h.writeLayout(i.layout, { breakpoints: i.breakpoints });
       });
-      node.appendChild(viewNode);
-      childRef.overrides.forEach((override) => {
-        if (override.properties) {
-          viewNode.writeProperties(override.properties, {
-            breakpoints: override.breakpoints
-          });
-        }
-        if (override.context) {
-          viewNode.writeContext(override.context, { breakpoints: override.breakpoints });
-        }
-        if (override.layout) {
-          viewNode.writeLayout(override.layout, { breakpoints: override.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: r,
+        branch: c
       });
-    } else if (platform.getComponentHandler(childDef.type)) {
-      const handle = platform.getComponentHandler(childDef.type);
-      if (handle) {
-        handle(childRef, {
-          platform,
-          node,
-          references,
-          definitions,
-          views,
-          branch
-        });
-      }
     } else {
-      const childDef2 = definitions[childRef.definitionId];
-      const childNode = platform.createNode(childDef2.type);
-      childNode.name = childRef.definitionId;
-      childNode.tags = childDef2.tags || [];
-      if (childDef2.properties) {
-        childNode.writeProperties(childDef2.properties);
-      }
-      if (childDef2.context) {
-        childNode.writeContext(childDef2.context);
-      }
-      if (childDef2.layout) {
-        childNode.writeLayout(childDef2.layout);
-      }
-      node.appendChild(childNode, branch);
-      childRef.overrides.forEach((override) => {
-        const options = { breakpoints: override.breakpoints };
-        if (override.properties) {
-          childNode.writeProperties(override.properties, options);
-        }
-        if (override.context) {
-          childNode.writeContext(override.context, options);
-        }
-        if (override.layout) {
-          childNode.writeLayout(override.layout, options);
-        }
-      });
-      if (childDef2.children) {
-        createChildren(platform, childNode, childDef2.children, definitions, views);
+      const h = s[a.definitionId];
+      if (process.env.NODE_ENV !== "production" && !h) {
+        O.error(`No definition found for component type '${a.definitionId}'.`);
+        return;
       }
+      const i = n.createNode(h.type);
+      i.name = a.definitionId, i.tags = h.tags || [], h.properties && i.writeProperties(h.properties), h.context && i.writeContext(h.context), h.layout && i.writeLayout(h.layout), t.appendChild(i, c), a.overrides.forEach((p) => {
+        const l = { breakpoints: p.breakpoints };
+        p.properties && i.writeProperties(p.properties, l), p.context && i.writeContext(p.context, l), p.layout && i.writeLayout(p.layout, l);
+      }), h.children && C(n, i, h.children, s, r);
     }
   });
-};
-const createComponentModel = (platform, settings) => {
-  const { entry, components, breakpoints, views } = settings;
-  const subscriptions = [];
-  Object.keys(breakpoints).forEach((name) => {
-    const query = breakpoints[name];
-    const list = window.matchMedia(query);
-    if (list.matches) {
-      platform.breakpoints.push(name);
-    }
-    const listener = (event) => {
-      if (event.matches) {
-        platform.addBreakpoint(name);
-      } else {
-        platform.removeBreakpoint(name);
-      }
+}, at = (n, t) => {
+  const { entry: e, components: s, breakpoints: r, views: c } = t, o = [];
+  return Object.keys(r).forEach((a) => {
+    const u = r[a], h = window.matchMedia(u);
+    h.matches && n.breakpoints.push(a);
+    const i = (p) => {
+      p.matches ? n.addBreakpoint(a) : n.removeBreakpoint(a);
     };
-    list.addListener(listener);
-    subscriptions.push(() => list.removeListener(listener));
-  });
-  createChildren(platform, platform.nodes.root, [entry], components, views);
-  return () => subscriptions.forEach((sub) => {
-    sub();
+    h.addListener(i), o.push(() => h.removeListener(i));
+  }), C(n, n.nodes.root, [e], s, c), () => o.forEach((a) => {
+    a();
   });
-};
-const asDescriptor = (node, branch) => {
-  return {
-    id: node.id,
-    type: node.type,
-    name: node.name,
-    branch: branch || "default"
+}, pt = (n, t) => ({
+  id: n.id,
+  type: n.type,
+  name: n.name,
+  branch: t || "default"
+}), ut = (n, t, e, s = E(), r = {}) => 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 i = a[h.id];
+    return i ? Promise.resolve(i.controller) : et.getInstance(n).then((p) => new $(p, h, s));
   };
-};
-const extendComponent = (container, typeOrQuery, handler, ns = uuid(), options = {}) => {
-  return container.getAsync("components").then((components) => {
-    let target;
-    if (typeof typeOrQuery === "string") {
-      const collection = new ComponentQuery(components);
-      collection.ofType(typeOrQuery);
-      target = collection;
-    } else {
-      target = typeOrQuery;
-    }
-    const managedInstances = {};
-    const getOrCreateController = (node) => {
-      const existing = managedInstances[node.id];
-      if (existing) {
-        return Promise.resolve(existing.controller);
-      }
-      return ComponentPlatform.getInstance(container).then((platform) => {
-        return new ComponentNodeController(platform, node, ns);
+  c.events.subscribe("components:node-enter", (h, { node: i }) => {
+    o.match(i) && u(i).then((p) => {
+      Promise.resolve(e(p)).then((l) => {
+        a[i.id] = {
+          dispose: l,
+          controller: p
+        };
       });
-    };
-    components.events.subscribe("components:node-enter", (event, { node }) => {
-      if (target.match(node)) {
-        getOrCreateController(node).then((controller) => {
-          Promise.resolve(handler(controller)).then((dispose) => {
-            managedInstances[node.id] = {
-              dispose,
-              controller
-            };
-          });
-        });
-      }
-    });
-    components.events.subscribe("components:node-exit", (event, { node }) => {
-      const instance = managedInstances[node.id];
-      if (instance) {
-        instance.dispose && instance.dispose();
-        if (!options.reuseController) {
-          instance.controller.dispose();
-          delete managedInstances[node.id];
-        }
-      }
     });
+  }), c.events.subscribe("components:node-exit", (h, { node: i }) => {
+    const p = a[i.id];
+    p && (p.dispose && p.dispose(), r.reuseController || (p.controller.dispose(), delete a[i.id]));
   });
-};
-class ComponentResolver {
-  constructor(container) {
-    this.aliases = /* @__PURE__ */ new Map();
-    this.components = /* @__PURE__ */ new Map();
-    this.logger = new Logger();
-    const { events } = container.get("$widget");
-    this.events = events;
-  }
-  getComponent(key) {
-    const alias = this.aliases.get(key);
-    const component = this.components.get(alias || key) || null;
-    return component;
-  }
-  registerComponent(key, component) {
-    this.components.set(key, component);
-    this.events.dispatch("component-resolver:resolve", key);
-    return () => {
-      this.components.delete(key);
+});
+class lt {
+  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(key, fn) {
-    return this.events.subscribe("component-resolver:resolve", (e, data) => {
-      if (data === key) {
-        const component = this.getComponent(key);
-        fn(component);
+  registerResolver(t, e) {
+    return this.events.subscribe("component-resolver:resolve", (s, r) => {
+      if (r === t) {
+        const c = this.getComponent(t);
+        e(c);
       }
     });
   }
-  registerAlias(alias, key) {
-    this.aliases.set(alias, key);
-    this.events.dispatch("component-resolver:resolve", alias);
-    return () => {
-      this.aliases.delete(alias);
+  registerAlias(t, e) {
+    return this.aliases.set(t, e), this.events.dispatch("component-resolver:resolve", t), () => {
+      this.aliases.delete(t);
     };
   }
 }
-var WidgetRenderState = /* @__PURE__ */ ((WidgetRenderState2) => {
-  WidgetRenderState2["open"] = "open";
-  WidgetRenderState2["closed"] = "closed";
-  WidgetRenderState2["hidden"] = "hidden";
-  return WidgetRenderState2;
-})(WidgetRenderState || {});
-export { ActionResolver, ActionsController, ComponentNode, ComponentNodeController, ComponentPlatform, ComponentQuery, ComponentResolver, WidgetRenderState, asDescriptor, componentConfigurationApi, createChildren, createComponentModel, createEventSubscriber, extendComponent, findComponent, findVisibleComponents, traverseComponents };
+var nt = /* @__PURE__ */ ((n) => (n.open = "open", n.closed = "closed", n.hidden = "hidden", n))(nt || {});
+export {
+  ct as ActionResolver,
+  k as ActionsController,
+  H as ComponentNode,
+  $ as ComponentNodeController,
+  et as ComponentPlatform,
+  N as ComponentQuery,
+  lt as ComponentResolver,
+  nt as WidgetRenderState,
+  pt as asDescriptor,
+  ht as componentConfigurationApi,
+  C as createChildren,
+  at as createComponentModel,
+  K as createEventSubscriber,
+  ut as extendComponent,
+  F as findComponent,
+  x as findVisibleComponents,
+  P as traverseComponents
+};
 //# sourceMappingURL=index.js.map