@oicl/openbridge-webcomponents 2.0.0-next.168 → 2.0.0-next.169

package/dist/internal/popover-controller.d.ts

@@ -0,0 +1,128 @@
+import { LitElement, ReactiveController } from 'lit';
+/**
+ * What {@link PopoverController} needs a component to have.
+ *
+ * `softDismiss` has to be something a component opts into. The browser hides
+ * a popover until it is opened, so switching this on for everyone would make
+ * every menu that a consumer already shows and positions disappear.
+ */
+export interface SoftDismissHost extends LitElement {
+    /** Let the browser take over showing, hiding and closing this panel. */
+    softDismiss: boolean;
+    /** Whether the panel is showing. Only used when `softDismiss` is on. */
+    open: boolean;
+}
+/**
+ * Lets a menu close itself the way people expect (#1293).
+ *
+ * Click outside an open menu and it should go away — and that click should
+ * do nothing else. So should pressing `Escape`. The browser does most of
+ * this on its own for an element marked as a popover, which is what this
+ * controller switches on, and it brings two things that are hard to get
+ * right by hand: focus returns to the button that opened the menu, and the
+ * menu is drawn above the rest of the page whatever its container does with
+ * `overflow`, `transform` or `z-index`.
+ *
+ * The one thing the browser will not do is swallow that outside click: left
+ * alone it closes the menu *and* presses whatever was underneath. So the
+ * controller gives the menu a see-through cover over the page, kept behind
+ * the menu's own content. The menu is drawn above everything else on the
+ * page, so its cover is too: clicks and hovers land on the cover instead of
+ * the page, and the cover closes the menu.
+ *
+ * The cover starts below the top bar, so the bar itself stays usable while a
+ * menu is open and moving from one menu to the next is a single click. Its
+ * top edge is `--topbar-height`, falling back to the top bar's size token; an
+ * app without a top bar sets that to `0`. Consumers can also restyle or tint
+ * it through `::part(backdrop)`.
+ *
+ * A component keeps `open` as the property people set. Since the browser can
+ * also open and close the menu on its own, the controller writes what the
+ * browser did back into `open`, and fires `close` when the menu went away by
+ * itself. Skip that and the property drifts out of step with what is on
+ * screen, and the next render closes a menu that was just opened.
+ *
+ * The button that opens the menu usually belongs to whoever is using the
+ * component, not to the component itself, so wiring it up is
+ * {@link bindPopoverTrigger}'s job.
+ */
+export declare class PopoverController implements ReactiveController {
+    private readonly host;
+    private installed;
+    private backdrop?;
+    /** Noted at a close that `open` did not ask for, so it can be reported. */
+    private dismissed;
+    /**
+     * True from `beforetoggle` to `toggle`, while the browser is mid-way through
+     * opening or closing. `sync()` stands down for that stretch: it would see
+     * `open` already updated but the menu not yet moved, and try to move it
+     * itself — nested inside the move the browser is making.
+     */
+    private toggling;
+    constructor(host: SoftDismissHost);
+    hostConnected(): void;
+    hostUpdated(): void;
+    hostDisconnected(): void;
+    /**
+     * The menu is about to open or close for a reason other than `open` being
+     * set — a button wired straight to it, `Escape`, a click on the cover, a
+     * direct `showPopover()`. `open` is brought into line here, at once.
+     *
+     * The browser offers two events for this and only `beforetoggle` arrives
+     * in time. It fires during the call that opens or closes the menu, while
+     * `toggle` waits its turn in the queue. A re-render can get in before that
+     * turn, read an `open` that still says the old thing, and undo what just
+     * happened — close a menu that was just opened, or reopen one that was
+     * just closed.
+     */
+    private readonly onBeforeToggle;
+    /**
+     * The menu has closed. Report it only when `open` did not ask for it.
+     *
+     * By now `open` is `false` either way — `beforetoggle` saw to that — so
+     * the note it left in `dismissed` is what tells the two apart.
+     *
+     * The `softDismiss` check keeps this out of the way of components that run
+     * a popover themselves. `obc-menu-button` does that with
+     * `obc-context-menu-input`, and those closes are its business.
+     */
+    private readonly onToggle;
+    private sync;
+    /**
+     * The see-through cover that swallows clicks while the menu is open.
+     *
+     * It is an ordinary child of the menu, not a popover of its own: the
+     * browser refuses to show one popover while another is on its way up, so
+     * the cover cannot be a popover shown as the menu opens. It does not need
+     * to be. The menu is drawn above the whole page, so a child of the menu
+     * that reaches over the page is drawn above the page as well, and a
+     * negative `z-index` keeps it behind the menu's own content. It shows and
+     * hides with the menu and never has to be told.
+     *
+     * Being inside the menu also means the browser treats a click on it as a
+     * click *inside* the menu and leaves the menu open — so the cover closes
+     * the menu itself.
+     */
+    private ensureCover;
+}
+/**
+ * Makes a button open and close a menu. Returns a function that unhooks it.
+ *
+ * Most such buttons sit in the top bar, which the cover leaves reachable, and
+ * that is where people get caught out. Clicking the button a second time
+ * looks like it should close the menu, but the browser has already closed it
+ * as the mouse went down, before the click arrives — so a handler that reads
+ * the live state opens it right back up and the menu looks stuck.
+ * Remembering the state as the mouse goes down is what makes the second click
+ * work. Keyboard presses never trigger that early close, so they read the
+ * live state; `MouseEvent.detail` is `0` only for the click that `Enter` and
+ * `Space` produce, which is how the two are told apart.
+ *
+ * `open` is not touched here: the controller mirrors what the browser does,
+ * in both directions, the moment it happens.
+ *
+ * HTML can pair a button with a popover on its own, but only inside the same
+ * component. Reach for this when the button and the menu live apart.
+ */
+export declare function bindPopoverTrigger(trigger: HTMLElement, panel: SoftDismissHost): () => void;
+//# sourceMappingURL=popover-controller.d.ts.map

package/dist/internal/popover-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover-controller.d.ts","sourceRoot":"","sources":["../../src/internal/popover-controller.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAE,kBAAkB,EAAC,MAAM,KAAK,CAAC;AAExD;;;;;;GAMG;AACH,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,wEAAwE;IACxE,WAAW,EAAE,OAAO,CAAC;IACrB,wEAAwE;IACxE,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAa9C,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAc;IAC/B,2EAA2E;IAC3E,OAAO,CAAC,SAAS,CAAS;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAS;gBAEI,IAAI,EAAE,eAAe;IAIlD,aAAa,IAAI,IAAI;IAQrB,WAAW,IAAI,IAAI;IAInB,gBAAgB,IAAI,IAAI;IAMxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,QAAQ,CAAC,cAAc,CAkB7B;IAEF;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAavB;IAEF,OAAO,CAAC,IAAI;IAiCZ;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,WAAW;CAiBpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,eAAe,GACrB,MAAM,IAAI,CAwBZ"}

package/dist/internal/popover-controller.js

@@ -0,0 +1,121 @@
+class PopoverController {
+  constructor(host) {
+    this.host = host;
+    this.installed = false;
+    this.dismissed = false;
+    this.toggling = false;
+    this.onBeforeToggle = (event) => {
+      if (!this.host.softDismiss) return;
+      this.toggling = true;
+      setTimeout(() => {
+        this.toggling = false;
+      }, 0);
+      if (event.newState === "open") {
+        this.ensureCover();
+        this.host.open = true;
+        return;
+      }
+      this.dismissed = this.host.open;
+      this.host.open = false;
+    };
+    this.onToggle = (event) => {
+      if (!this.host.softDismiss) return;
+      this.toggling = false;
+      if (event.newState !== "closed") return;
+      if (!this.dismissed) return;
+      this.dismissed = false;
+      this.host.dispatchEvent(new CustomEvent("close"));
+    };
+    host.addController(this);
+  }
+  hostConnected() {
+    this.host.addEventListener("beforetoggle", this.onBeforeToggle);
+    this.host.addEventListener("toggle", this.onToggle);
+    if (this.host.hasUpdated) {
+      this.sync();
+    }
+  }
+  hostUpdated() {
+    this.sync();
+  }
+  hostDisconnected() {
+    this.host.removeEventListener("beforetoggle", this.onBeforeToggle);
+    this.host.removeEventListener("toggle", this.onToggle);
+    this.toggling = false;
+  }
+  sync() {
+    const host = this.host;
+    if (!host.softDismiss) {
+      if (this.installed) {
+        host.removeAttribute("popover");
+        this.installed = false;
+        this.backdrop?.remove();
+        this.backdrop = void 0;
+      }
+      return;
+    }
+    if (!this.installed) {
+      host.setAttribute("popover", "auto");
+      this.installed = true;
+      this.ensureCover();
+    }
+    if (!host.isConnected) return;
+    if (this.toggling) return;
+    const isOpen = host.matches(":popover-open");
+    if (host.open && !isOpen) {
+      host.showPopover();
+    } else if (!host.open && isOpen) {
+      host.hidePopover();
+    }
+  }
+  /**
+   * The see-through cover that swallows clicks while the menu is open.
+   *
+   * It is an ordinary child of the menu, not a popover of its own: the
+   * browser refuses to show one popover while another is on its way up, so
+   * the cover cannot be a popover shown as the menu opens. It does not need
+   * to be. The menu is drawn above the whole page, so a child of the menu
+   * that reaches over the page is drawn above the page as well, and a
+   * negative `z-index` keeps it behind the menu's own content. It shows and
+   * hides with the menu and never has to be told.
+   *
+   * Being inside the menu also means the browser treats a click on it as a
+   * click *inside* the menu and leaves the menu open — so the cover closes
+   * the menu itself.
+   */
+  ensureCover() {
+    const root = this.host.shadowRoot;
+    if (!root || this.backdrop) return;
+    const cover = document.createElement("div");
+    cover.setAttribute("part", "backdrop");
+    cover.style.cssText = "position:fixed;top:var(--topbar-height,var(--app-components-topbar-touch-target-size,0px));right:0;bottom:0;left:0;z-index:-1;margin:0;padding:0;border:0;background:transparent";
+    cover.addEventListener("click", () => this.host.hidePopover());
+    root.append(cover);
+    this.backdrop = cover;
+  }
+}
+function bindPopoverTrigger(trigger, panel) {
+  let openBeforeAutoClose = false;
+  const onPointerDown = () => {
+    openBeforeAutoClose = panel.matches(":popover-open");
+  };
+  const onClick = (event) => {
+    const wasOpen = event.detail > 0 ? openBeforeAutoClose : panel.matches(":popover-open");
+    if (wasOpen) {
+      panel.hidePopover();
+    } else {
+      panel.showPopover();
+    }
+  };
+  trigger.addEventListener("pointerdown", onPointerDown);
+  trigger.addEventListener("click", onClick);
+  return () => {
+    trigger.removeEventListener("pointerdown", onPointerDown);
+    trigger.removeEventListener("click", onClick);
+  };
+}
+export {
+  PopoverController,
+  bindPopoverTrigger
+};
+//# sourceMappingURL=popover-controller.js.map

package/dist/internal/popover-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"popover-controller.js","sources":["../../src/internal/popover-controller.ts"],"sourcesContent":["import type {LitElement, ReactiveController} from 'lit';\n\n/**\n * What {@link PopoverController} needs a component to have.\n *\n * `softDismiss` has to be something a component opts into. The browser hides\n * a popover until it is opened, so switching this on for everyone would make\n * every menu that a consumer already shows and positions disappear.\n */\nexport interface SoftDismissHost extends LitElement {\n  /** Let the browser take over showing, hiding and closing this panel. */\n  softDismiss: boolean;\n  /** Whether the panel is showing. Only used when `softDismiss` is on. */\n  open: boolean;\n}\n\n/**\n * Lets a menu close itself the way people expect (#1293).\n *\n * Click outside an open menu and it should go away — and that click should\n * do nothing else. So should pressing `Escape`. The browser does most of\n * this on its own for an element marked as a popover, which is what this\n * controller switches on, and it brings two things that are hard to get\n * right by hand: focus returns to the button that opened the menu, and the\n * menu is drawn above the rest of the page whatever its container does with\n * `overflow`, `transform` or `z-index`.\n *\n * The one thing the browser will not do is swallow that outside click: left\n * alone it closes the menu *and* presses whatever was underneath. So the\n * controller gives the menu a see-through cover over the page, kept behind\n * the menu's own content. The menu is drawn above everything else on the\n * page, so its cover is too: clicks and hovers land on the cover instead of\n * the page, and the cover closes the menu.\n *\n * The cover starts below the top bar, so the bar itself stays usable while a\n * menu is open and moving from one menu to the next is a single click. Its\n * top edge is `--topbar-height`, falling back to the top bar's size token; an\n * app without a top bar sets that to `0`. Consumers can also restyle or tint\n * it through `::part(backdrop)`.\n *\n * A component keeps `open` as the property people set. Since the browser can\n * also open and close the menu on its own, the controller writes what the\n * browser did back into `open`, and fires `close` when the menu went away by\n * itself. Skip that and the property drifts out of step with what is on\n * screen, and the next render closes a menu that was just opened.\n *\n * The button that opens the menu usually belongs to whoever is using the\n * component, not to the component itself, so wiring it up is\n * {@link bindPopoverTrigger}'s job.\n */\nexport class PopoverController implements ReactiveController {\n  private installed = false;\n  private backdrop?: HTMLElement;\n  /** Noted at a close that `open` did not ask for, so it can be reported. */\n  private dismissed = false;\n  /**\n   * True from `beforetoggle` to `toggle`, while the browser is mid-way through\n   * opening or closing. `sync()` stands down for that stretch: it would see\n   * `open` already updated but the menu not yet moved, and try to move it\n   * itself — nested inside the move the browser is making.\n   */\n  private toggling = false;\n\n  constructor(private readonly host: SoftDismissHost) {\n    host.addController(this);\n  }\n\n  hostConnected(): void {\n    this.host.addEventListener('beforetoggle', this.onBeforeToggle);\n    this.host.addEventListener('toggle', this.onToggle);\n    if (this.host.hasUpdated) {\n      this.sync();\n    }\n  }\n\n  hostUpdated(): void {\n    this.sync();\n  }\n\n  hostDisconnected(): void {\n    this.host.removeEventListener('beforetoggle', this.onBeforeToggle);\n    this.host.removeEventListener('toggle', this.onToggle);\n    this.toggling = false;\n  }\n\n  /**\n   * The menu is about to open or close for a reason other than `open` being\n   * set — a button wired straight to it, `Escape`, a click on the cover, a\n   * direct `showPopover()`. `open` is brought into line here, at once.\n   *\n   * The browser offers two events for this and only `beforetoggle` arrives\n   * in time. It fires during the call that opens or closes the menu, while\n   * `toggle` waits its turn in the queue. A re-render can get in before that\n   * turn, read an `open` that still says the old thing, and undo what just\n   * happened — close a menu that was just opened, or reopen one that was\n   * just closed.\n   */\n  private readonly onBeforeToggle = (event: Event): void => {\n    if (!this.host.softDismiss) return;\n    this.toggling = true;\n    // `toggle` clears this. Should it never come — someone cancelled the\n    // opening — the flag must not stay up, or `open` could never drive the\n    // menu again. A timer runs after the browser has finished either way.\n    setTimeout(() => {\n      this.toggling = false;\n    }, 0);\n    if ((event as ToggleEvent).newState === 'open') {\n      this.ensureCover();\n      this.host.open = true;\n      return;\n    }\n    // `open` is already false when this controller asked for the close;\n    // still true means somebody else did, and the consumer should hear.\n    this.dismissed = this.host.open;\n    this.host.open = false;\n  };\n\n  /**\n   * The menu has closed. Report it only when `open` did not ask for it.\n   *\n   * By now `open` is `false` either way — `beforetoggle` saw to that — so\n   * the note it left in `dismissed` is what tells the two apart.\n   *\n   * The `softDismiss` check keeps this out of the way of components that run\n   * a popover themselves. `obc-menu-button` does that with\n   * `obc-context-menu-input`, and those closes are its business.\n   */\n  private readonly onToggle = (event: Event): void => {\n    if (!this.host.softDismiss) return;\n    this.toggling = false;\n    if ((event as ToggleEvent).newState !== 'closed') return;\n    if (!this.dismissed) return;\n    this.dismissed = false;\n    /**\n     * Fired when the popover closed on its own — a click outside, `Escape`,\n     * or another popover opening.\n     * @event close\n     * @type {CustomEvent<void>}\n     */\n    this.host.dispatchEvent(new CustomEvent('close'));\n  };\n\n  private sync(): void {\n    const host = this.host;\n\n    if (!host.softDismiss) {\n      if (this.installed) {\n        // Dropping the attribute puts the component back to an ordinary\n        // element, which is what it was before opting in.\n        host.removeAttribute('popover');\n        this.installed = false;\n        this.backdrop?.remove();\n        this.backdrop = undefined;\n      }\n      return;\n    }\n\n    if (!this.installed) {\n      host.setAttribute('popover', 'auto');\n      this.installed = true;\n      this.ensureCover();\n    }\n\n    // Showing a popover that is not on the page throws.\n    if (!host.isConnected) return;\n    if (this.toggling) return;\n\n    const isOpen = host.matches(':popover-open');\n    if (host.open && !isOpen) {\n      host.showPopover();\n    } else if (!host.open && isOpen) {\n      host.hidePopover();\n    }\n  }\n\n  /**\n   * The see-through cover that swallows clicks while the menu is open.\n   *\n   * It is an ordinary child of the menu, not a popover of its own: the\n   * browser refuses to show one popover while another is on its way up, so\n   * the cover cannot be a popover shown as the menu opens. It does not need\n   * to be. The menu is drawn above the whole page, so a child of the menu\n   * that reaches over the page is drawn above the page as well, and a\n   * negative `z-index` keeps it behind the menu's own content. It shows and\n   * hides with the menu and never has to be told.\n   *\n   * Being inside the menu also means the browser treats a click on it as a\n   * click *inside* the menu and leaves the menu open — so the cover closes\n   * the menu itself.\n   */\n  private ensureCover(): void {\n    const root = this.host.shadowRoot;\n    if (!root || this.backdrop) return;\n    const cover = document.createElement('div');\n    cover.setAttribute('part', 'backdrop');\n    // The last fallback keeps the whole page covered where no palette is\n    // loaded; an `auto` top would leave the cover wherever it happened to\n    // land.\n    cover.style.cssText =\n      'position:fixed;' +\n      'top:var(--topbar-height,var(--app-components-topbar-touch-target-size,0px));' +\n      'right:0;bottom:0;left:0;z-index:-1;margin:0;padding:0;border:0;' +\n      'background:transparent';\n    cover.addEventListener('click', () => this.host.hidePopover());\n    root.append(cover);\n    this.backdrop = cover;\n  }\n}\n\n/**\n * Makes a button open and close a menu. Returns a function that unhooks it.\n *\n * Most such buttons sit in the top bar, which the cover leaves reachable, and\n * that is where people get caught out. Clicking the button a second time\n * looks like it should close the menu, but the browser has already closed it\n * as the mouse went down, before the click arrives — so a handler that reads\n * the live state opens it right back up and the menu looks stuck.\n * Remembering the state as the mouse goes down is what makes the second click\n * work. Keyboard presses never trigger that early close, so they read the\n * live state; `MouseEvent.detail` is `0` only for the click that `Enter` and\n * `Space` produce, which is how the two are told apart.\n *\n * `open` is not touched here: the controller mirrors what the browser does,\n * in both directions, the moment it happens.\n *\n * HTML can pair a button with a popover on its own, but only inside the same\n * component. Reach for this when the button and the menu live apart.\n */\nexport function bindPopoverTrigger(\n  trigger: HTMLElement,\n  panel: SoftDismissHost\n): () => void {\n  let openBeforeAutoClose = false;\n\n  const onPointerDown = (): void => {\n    openBeforeAutoClose = panel.matches(':popover-open');\n  };\n\n  const onClick = (event: MouseEvent): void => {\n    const wasOpen =\n      event.detail > 0 ? openBeforeAutoClose : panel.matches(':popover-open');\n    if (wasOpen) {\n      panel.hidePopover();\n    } else {\n      panel.showPopover();\n    }\n  };\n\n  trigger.addEventListener('pointerdown', onPointerDown);\n  trigger.addEventListener('click', onClick);\n\n  return () => {\n    trigger.removeEventListener('pointerdown', onPointerDown);\n    trigger.removeEventListener('click', onClick);\n  };\n}\n"],"names":[],"mappings":"AAkDO,MAAM,kBAAgD;AAAA,EAa3D,YAA6B,MAAuB;AAAvB,SAAA,OAAA;AAZ7B,SAAQ,YAAY;AAGpB,SAAQ,YAAY;AAOpB,SAAQ,WAAW;AAoCnB,SAAiB,iBAAiB,CAAC,UAAuB;AACxD,UAAI,CAAC,KAAK,KAAK,YAAa;AAC5B,WAAK,WAAW;AAIhB,iBAAW,MAAM;AACf,aAAK,WAAW;AAAA,MAClB,GAAG,CAAC;AACJ,UAAK,MAAsB,aAAa,QAAQ;AAC9C,aAAK,YAAA;AACL,aAAK,KAAK,OAAO;AACjB;AAAA,MACF;AAGA,WAAK,YAAY,KAAK,KAAK;AAC3B,WAAK,KAAK,OAAO;AAAA,IACnB;AAYA,SAAiB,WAAW,CAAC,UAAuB;AAClD,UAAI,CAAC,KAAK,KAAK,YAAa;AAC5B,WAAK,WAAW;AAChB,UAAK,MAAsB,aAAa,SAAU;AAClD,UAAI,CAAC,KAAK,UAAW;AACrB,WAAK,YAAY;AAOjB,WAAK,KAAK,cAAc,IAAI,YAAY,OAAO,CAAC;AAAA,IAClD;AA5EE,SAAK,cAAc,IAAI;AAAA,EACzB;AAAA,EAEA,gBAAsB;AACpB,SAAK,KAAK,iBAAiB,gBAAgB,KAAK,cAAc;AAC9D,SAAK,KAAK,iBAAiB,UAAU,KAAK,QAAQ;AAClD,QAAI,KAAK,KAAK,YAAY;AACxB,WAAK,KAAA;AAAA,IACP;AAAA,EACF;AAAA,EAEA,cAAoB;AAClB,SAAK,KAAA;AAAA,EACP;AAAA,EAEA,mBAAyB;AACvB,SAAK,KAAK,oBAAoB,gBAAgB,KAAK,cAAc;AACjE,SAAK,KAAK,oBAAoB,UAAU,KAAK,QAAQ;AACrD,SAAK,WAAW;AAAA,EAClB;AAAA,EA2DQ,OAAa;AACnB,UAAM,OAAO,KAAK;AAElB,QAAI,CAAC,KAAK,aAAa;AACrB,UAAI,KAAK,WAAW;AAGlB,aAAK,gBAAgB,SAAS;AAC9B,aAAK,YAAY;AACjB,aAAK,UAAU,OAAA;AACf,aAAK,WAAW;AAAA,MAClB;AACA;AAAA,IACF;AAEA,QAAI,CAAC,KAAK,WAAW;AACnB,WAAK,aAAa,WAAW,MAAM;AACnC,WAAK,YAAY;AACjB,WAAK,YAAA;AAAA,IACP;AAGA,QAAI,CAAC,KAAK,YAAa;AACvB,QAAI,KAAK,SAAU;AAEnB,UAAM,SAAS,KAAK,QAAQ,eAAe;AAC3C,QAAI,KAAK,QAAQ,CAAC,QAAQ;AACxB,WAAK,YAAA;AAAA,IACP,WAAW,CAAC,KAAK,QAAQ,QAAQ;AAC/B,WAAK,YAAA;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBQ,cAAoB;AAC1B,UAAM,OAAO,KAAK,KAAK;AACvB,QAAI,CAAC,QAAQ,KAAK,SAAU;AAC5B,UAAM,QAAQ,SAAS,cAAc,KAAK;AAC1C,UAAM,aAAa,QAAQ,UAAU;AAIrC,UAAM,MAAM,UACV;AAIF,UAAM,iBAAiB,SAAS,MAAM,KAAK,KAAK,aAAa;AAC7D,SAAK,OAAO,KAAK;AACjB,SAAK,WAAW;AAAA,EAClB;AACF;AAqBO,SAAS,mBACd,SACA,OACY;AACZ,MAAI,sBAAsB;AAE1B,QAAM,gBAAgB,MAAY;AAChC,0BAAsB,MAAM,QAAQ,eAAe;AAAA,EACrD;AAEA,QAAM,UAAU,CAAC,UAA4B;AAC3C,UAAM,UACJ,MAAM,SAAS,IAAI,sBAAsB,MAAM,QAAQ,eAAe;AACxE,QAAI,SAAS;AACX,YAAM,YAAA;AAAA,IACR,OAAO;AACL,YAAM,YAAA;AAAA,IACR;AAAA,EACF;AAEA,UAAQ,iBAAiB,eAAe,aAAa;AACrD,UAAQ,iBAAiB,SAAS,OAAO;AAEzC,SAAO,MAAM;AACX,YAAQ,oBAAoB,eAAe,aAAa;AACxD,YAAQ,oBAAoB,SAAS,OAAO;AAAA,EAC9C;AACF;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oicl/openbridge-webcomponents",
-  "version": "2.0.0-next.168",
+  "version": "2.0.0-next.169",
   "type": "module",
   "repository": {
     "type": "git",