@uplynk/lynk-design 1.17.1 → 1.18.0

package/dist/chunks/chunk.SCLSEGSN.js

@@ -0,0 +1,277 @@
+import {
+  tooltip_styles_default
+} from "./chunk.FGRWDPVX.js";
+import {
+  LynkPopup
+} from "./chunk.GN427G2P.js";
+import {
+  waitForEvent
+} from "./chunk.B4BZKR24.js";
+import {
+  animateTo,
+  parseDuration,
+  stopAnimations
+} from "./chunk.5SGOC3ZM.js";
+import {
+  getAnimation,
+  setDefaultAnimation
+} from "./chunk.SPWJX47D.js";
+import {
+  LocalizeController
+} from "./chunk.NJBJM2FD.js";
+import {
+  watch
+} from "./chunk.GQZ7EGMM.js";
+import {
+  LynkElement
+} from "./chunk.XVGZ4RY7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.Q44EX5TP.js";
+
+// src/components/tooltip/tooltip.component.ts
+import { classMap } from "lit/directives/class-map.js";
+import { html } from "lit";
+import { property, query } from "lit/decorators.js";
+var LynkTooltip = class extends LynkElement {
+  constructor() {
+    super();
+    this.localize = new LocalizeController(this);
+    this.content = "";
+    this.placement = "top";
+    this.disabled = false;
+    this.distance = 8;
+    this.open = false;
+    this.skidding = 0;
+    this.noArrow = false;
+    this.trigger = "hover focus";
+    this.hoist = false;
+    this.handleBlur = () => {
+      if (this.hasTrigger("focus")) {
+        this.hide();
+      }
+    };
+    this.handleClick = () => {
+      if (this.hasTrigger("click")) {
+        if (this.open) {
+          this.hide();
+        } else {
+          this.show();
+        }
+      }
+    };
+    this.handleFocus = () => {
+      if (this.hasTrigger("focus")) {
+        this.show();
+      }
+    };
+    this.handleDocumentKeyDown = (event) => {
+      if (this.open && event.key === "Escape") {
+        event.stopPropagation();
+        this.hide();
+      }
+    };
+    this.handleMouseOver = () => {
+      if (this.hasTrigger("hover")) {
+        const delay = parseDuration(getComputedStyle(this).getPropertyValue("--show-delay"));
+        clearTimeout(this.hoverTimeout);
+        this.hoverTimeout = window.setTimeout(() => void this.show(), delay);
+      }
+    };
+    this.handleMouseOut = () => {
+      if (this.hasTrigger("hover")) {
+        const delay = parseDuration(getComputedStyle(this).getPropertyValue("--hide-delay"));
+        clearTimeout(this.hoverTimeout);
+        this.hoverTimeout = window.setTimeout(() => void this.hide(), delay);
+      }
+    };
+    this.addEventListener("blur", this.handleBlur, true);
+    this.addEventListener("focus", this.handleFocus, true);
+    this.addEventListener("click", this.handleClick);
+    this.addEventListener("mouseover", this.handleMouseOver);
+    this.addEventListener("mouseout", this.handleMouseOut);
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = this.closeWatcher) == null ? void 0 : _a.destroy();
+    document.removeEventListener("keydown", this.handleDocumentKeyDown);
+  }
+  firstUpdated() {
+    this.body.hidden = !this.open;
+    if (this.open) {
+      this.popup.active = true;
+      this.popup.reposition();
+    }
+  }
+  hasTrigger(triggerType) {
+    const triggers = this.trigger.split(" ");
+    return triggers.includes(triggerType);
+  }
+  async handleOpenChange() {
+    var _a, _b;
+    if (this.open) {
+      if (this.disabled) {
+        return;
+      }
+      this.emit("ev-show");
+      if ("CloseWatcher" in window) {
+        (_a = this.closeWatcher) == null ? void 0 : _a.destroy();
+        this.closeWatcher = new CloseWatcher();
+        this.closeWatcher.onclose = () => {
+          this.hide();
+        };
+      } else {
+        document.addEventListener("keydown", this.handleDocumentKeyDown);
+      }
+      await stopAnimations(this.body);
+      this.body.hidden = false;
+      this.popup.active = true;
+      const { keyframes, options } = getAnimation(this, "tooltip.show", { dir: this.localize.dir() });
+      await animateTo(this.popup.popup, keyframes, options);
+      this.emit("ev-after-show");
+    } else {
+      this.emit("ev-hide");
+      (_b = this.closeWatcher) == null ? void 0 : _b.destroy();
+      document.removeEventListener("keydown", this.handleDocumentKeyDown);
+      await stopAnimations(this.body);
+      const { keyframes, options } = getAnimation(this, "tooltip.hide", { dir: this.localize.dir() });
+      await animateTo(this.popup.popup, keyframes, options);
+      this.popup.active = false;
+      this.body.hidden = true;
+      this.emit("ev-after-hide");
+    }
+  }
+  async handleOptionsChange() {
+    if (this.hasUpdated) {
+      await this.updateComplete;
+      this.popup.reposition();
+    }
+  }
+  handleDisabledChange() {
+    if (this.disabled && this.open) {
+      this.hide();
+    }
+  }
+  /** Shows the tooltip. */
+  async show() {
+    if (this.open) {
+      return void 0;
+    }
+    this.open = true;
+    return waitForEvent(this, "ev-after-show");
+  }
+  /** Hides the tooltip */
+  async hide() {
+    if (!this.open) {
+      return void 0;
+    }
+    this.open = false;
+    return waitForEvent(this, "ev-after-hide");
+  }
+  //
+  // NOTE: Tooltip is a bit unique in that we're using aria-live instead of aria-labelledby to trick screen readers into
+  // announcing the content. It works really well, but it violates an accessibility rule. We're also adding the
+  // aria-describedby attribute to a slot, which is required by <sl-popup> to correctly locate the first assigned
+  // element, otherwise positioning is incorrect.
+  //
+  render() {
+    return html`
+      <lynk-popup
+        part="base"
+        exportparts="
+          popup:base__popup,
+          arrow:base__arrow
+        "
+        class=${classMap({
+      tooltip: true,
+      "tooltip--open": this.open
+    })}
+        placement=${this.placement}
+        distance=${this.distance}
+        skidding=${this.skidding}
+        strategy=${this.hoist ? "fixed" : "absolute"}
+        flip
+        shift
+        ?arrow=${!this.noArrow}
+        hover-bridge
+      >
+        ${""}
+        <slot slot="anchor" aria-describedby="tooltip"></slot>
+
+        ${""}
+        <div part="body" id="tooltip" class="tooltip__body" role="tooltip" aria-live=${this.open ? "polite" : "off"}>
+          <slot name="content">${this.content}</slot>
+        </div>
+      </lynk-popup>
+    `;
+  }
+};
+LynkTooltip.styles = [component_styles_default, tooltip_styles_default];
+LynkTooltip.dependencies = { "lynk-popup": LynkPopup };
+__decorateClass([
+  query("slot:not([name])")
+], LynkTooltip.prototype, "defaultSlot", 2);
+__decorateClass([
+  query(".tooltip__body")
+], LynkTooltip.prototype, "body", 2);
+__decorateClass([
+  query("lynk-popup")
+], LynkTooltip.prototype, "popup", 2);
+__decorateClass([
+  property()
+], LynkTooltip.prototype, "content", 2);
+__decorateClass([
+  property()
+], LynkTooltip.prototype, "placement", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkTooltip.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: Number })
+], LynkTooltip.prototype, "distance", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkTooltip.prototype, "open", 2);
+__decorateClass([
+  property({ type: Number })
+], LynkTooltip.prototype, "skidding", 2);
+__decorateClass([
+  property({ attribute: "no-arrow", type: Boolean, reflect: true })
+], LynkTooltip.prototype, "noArrow", 2);
+__decorateClass([
+  property()
+], LynkTooltip.prototype, "trigger", 2);
+__decorateClass([
+  property({ type: Boolean })
+], LynkTooltip.prototype, "hoist", 2);
+__decorateClass([
+  watch("open", { waitUntilFirstUpdate: true })
+], LynkTooltip.prototype, "handleOpenChange", 1);
+__decorateClass([
+  watch(["content", "distance", "hoist", "placement", "skidding"])
+], LynkTooltip.prototype, "handleOptionsChange", 1);
+__decorateClass([
+  watch("disabled")
+], LynkTooltip.prototype, "handleDisabledChange", 1);
+setDefaultAnimation("tooltip.show", {
+  keyframes: [
+    { opacity: 0, scale: 0.8 },
+    { opacity: 1, scale: 1 }
+  ],
+  options: { duration: 150, easing: "ease" }
+});
+setDefaultAnimation("tooltip.hide", {
+  keyframes: [
+    { opacity: 1, scale: 1 },
+    { opacity: 0, scale: 0.8 }
+  ],
+  options: { duration: 150, easing: "ease" }
+});
+
+export {
+  LynkTooltip
+};

package/dist/chunks/chunk.SFUA62KN.js

@@ -0,0 +1,26 @@
+import {
+  LynkSplitter
+} from "./chunk.SA2YJJL7.js";
+
+// src/react/splitter/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-splitter";
+LynkSplitter.define("lynk-splitter");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkSplitter,
+  react: React,
+  events: {
+    EvReady: "ev-ready",
+    EvSplitterResize: "ev-splitter-resize",
+    EvAfterSplitterResize: "ev-after-splitter-resize"
+  },
+  displayName: "LynkSplitter"
+});
+var splitter_default = reactWrapper;
+
+export {
+  splitter_default
+};

package/dist/chunks/chunk.SHIEJQJ2.js

@@ -0,0 +1,21 @@
+import {
+  LynkPageFooter
+} from "./chunk.VMP46GWZ.js";
+
+// src/react/page-footer/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "lynk-page-footer";
+LynkPageFooter.define("lynk-page-footer");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkPageFooter,
+  react: React,
+  events: {},
+  displayName: "LynkPageFooter"
+});
+var page_footer_default = reactWrapper;
+
+export {
+  page_footer_default
+};

package/dist/chunks/chunk.SJNXK7WQ.js

@@ -0,0 +1,21 @@
+import {
+  LynkOption
+} from "./chunk.JO6X7DVB.js";
+
+// src/react/option/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "lynk-option";
+LynkOption.define("lynk-option");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkOption,
+  react: React,
+  events: {},
+  displayName: "LynkOption"
+});
+var option_default = reactWrapper;
+
+export {
+  option_default
+};

package/dist/chunks/chunk.SKX2CVTA.js

@@ -0,0 +1,11 @@
+import {
+  LynkPanel
+} from "./chunk.OTHCVKK7.js";
+
+// src/components/panel/panel.ts
+var panel_default = LynkPanel;
+LynkPanel.define("lynk-panel");
+
+export {
+  panel_default
+};

package/dist/chunks/chunk.SLYX4VGB.js

@@ -0,0 +1,11 @@
+import {
+  LynkAlert
+} from "./chunk.QOSVLUGZ.js";
+
+// src/components/alert/alert.ts
+var alert_default = LynkAlert;
+LynkAlert.define("lynk-alert");
+
+export {
+  alert_default
+};

package/dist/chunks/chunk.SSDKUDTO.js

@@ -0,0 +1,25 @@
+import {
+  LynkRadioButton
+} from "./chunk.JBMUCCSB.js";
+
+// src/react/radio-button/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-radio-button";
+LynkRadioButton.define("lynk-radio-button");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkRadioButton,
+  react: React,
+  events: {
+    EvBlur: "ev-blur",
+    EvFocus: "ev-focus"
+  },
+  displayName: "LynkRadioButton"
+});
+var radio_button_default = reactWrapper;
+
+export {
+  radio_button_default
+};

package/dist/chunks/chunk.T2XX5XJE.js

@@ -0,0 +1,11 @@
+import {
+  LynkDialog
+} from "./chunk.WAPDMTIV.js";
+
+// src/components/dialog/dialog.ts
+var dialog_default = LynkDialog;
+LynkDialog.define("lynk-dialog");
+
+export {
+  dialog_default
+};

package/dist/chunks/chunk.T2Z5LZHV.js

@@ -0,0 +1,82 @@
+import {
+  accordion_styles_default
+} from "./chunk.WBFUO5PD.js";
+import {
+  LynkElement
+} from "./chunk.XVGZ4RY7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.Q44EX5TP.js";
+
+// src/components/accordion/accordion.component.ts
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+var LynkAccordion = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.panels = [];
+    this.multiple = false;
+  }
+  syncPanels() {
+    var _a;
+    const slot = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector("slot");
+    if (slot) {
+      this.panels = slot.assignedElements({ flatten: true }).filter((el) => el.tagName.toLowerCase() === "lynk-panel");
+    }
+  }
+  handleSlotChange() {
+    this.syncPanels();
+  }
+  handlePanelToggle(event) {
+    if (this.multiple) {
+      return;
+    }
+    const target = event.target.closest("lynk-panel");
+    if (target.disabled) {
+      return;
+    }
+    this.panels.forEach((panel) => panel.expanded = panel === target);
+  }
+  /** Expands all panels. */
+  expandAll() {
+    this.panels.forEach((panel) => panel.expanded = true);
+  }
+  /** Collapses all panels */
+  collapseAll() {
+    this.panels.forEach((panel) => panel.expanded = false);
+  }
+  render() {
+    return html`
+      <slot
+        part="base"
+        class=${classMap({
+      accordion: true,
+      "accordion--square": this.shape === "square",
+      "accordion--flush": this.density === "flush",
+      "accordion--compact": this.density === "compact",
+      "accordion--comfy": this.density === "comfy"
+    })}
+        @ev-expand=${this.handlePanelToggle}
+        @slotchange=${this.handleSlotChange}
+      ></slot>
+    `;
+  }
+};
+LynkAccordion.styles = [component_styles_default, accordion_styles_default];
+__decorateClass([
+  property({ type: Boolean })
+], LynkAccordion.prototype, "multiple", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkAccordion.prototype, "density", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkAccordion.prototype, "shape", 2);
+
+export {
+  LynkAccordion
+};

package/dist/chunks/chunk.T6PTBJDE.js

@@ -0,0 +1,11 @@
+import {
+  LynkCol
+} from "./chunk.XVTOGML5.js";
+
+// src/components/col/col.ts
+var col_default = LynkCol;
+LynkCol.define("lynk-col");
+
+export {
+  col_default
+};

package/dist/chunks/chunk.TERK7ZBZ.js

@@ -0,0 +1,34 @@
+import {
+  page_styles_default
+} from "./chunk.JUUCWPYD.js";
+import {
+  LynkElement
+} from "./chunk.XVGZ4RY7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+
+// src/components/page/page.component.ts
+import { html } from "lit";
+var LynkPage = class extends LynkElement {
+  render() {
+    return html`
+      <div part="base" class="page">
+        <slot name="header" part="header" class="page__header"></slot>
+        <slot name="left-sidebar" part="left-sidebar" class="page__left-sidebar"></slot>
+        <slot name="left-inset-sidebar" part="left-inset-sidebar" class="page__left-inset-sidebar"></slot>
+        <div part="main" class="page__main">
+          <slot></slot>
+        </div>
+        <slot name="right-sidebar" part="right-sidebar" class="page__right-sidebar"></slot>
+        <slot name="right-inset-sidebar" part="right-inset-sidebar" class="page__right-inset-sidebar"></slot>
+        <slot name="footer" part="footer" class="page__footer"></slot>
+      </div>
+    `;
+  }
+};
+LynkPage.styles = [component_styles_default, page_styles_default];
+
+export {
+  LynkPage
+};

package/dist/chunks/chunk.TEUKB6GO.js

@@ -0,0 +1,11 @@
+import {
+  LynkGrid
+} from "./chunk.VBD62U35.js";
+
+// src/components/grid/grid.ts
+var grid_default = LynkGrid;
+LynkGrid.define("lynk-grid");
+
+export {
+  grid_default
+};

package/dist/chunks/chunk.TG5AFWQX.js

@@ -0,0 +1,11 @@
+import {
+  LynkRadio
+} from "./chunk.QV6BVIEK.js";
+
+// src/components/radio/radio.ts
+var radio_default = LynkRadio;
+LynkRadio.define("lynk-radio");
+
+export {
+  radio_default
+};

package/dist/chunks/chunk.TGANX7FP.js

@@ -0,0 +1,21 @@
+import {
+  LynkThead
+} from "./chunk.GPDKMEQU.js";
+
+// src/react/thead/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "lynk-thead";
+LynkThead.define("lynk-thead");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkThead,
+  react: React,
+  events: {},
+  displayName: "LynkThead"
+});
+var thead_default = reactWrapper;
+
+export {
+  thead_default
+};

package/dist/chunks/chunk.THMNLTAS.js

@@ -0,0 +1,87 @@
+import {
+  intersection_observer_styles_default
+} from "./chunk.UMHXN4BR.js";
+import {
+  watch
+} from "./chunk.GQZ7EGMM.js";
+import {
+  LynkElement
+} from "./chunk.XVGZ4RY7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.Q44EX5TP.js";
+
+// src/components/intersection-observer/intersection-observer.component.ts
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+var LynkIntersectionObserver = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.observedElements = [];
+    this.disabled = false;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.intersectionObserver = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        console.log(entry);
+        if (entry.intersectionRatio > 0) {
+          this.emit("ev-enter-view", { detail: { entry } });
+        } else {
+          this.emit("ev-exit-view", { detail: { entry } });
+        }
+      });
+    });
+    if (!this.disabled) {
+      this.startObserver();
+    }
+  }
+  handleSlotChange() {
+    if (!this.disabled) {
+      this.startObserver();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.stopObserver();
+  }
+  startObserver() {
+    const slot = this.shadowRoot.querySelector("slot");
+    if (slot !== null) {
+      const elements = slot.assignedElements({ flatten: true });
+      this.observedElements.forEach((el) => this.intersectionObserver.unobserve(el));
+      this.observedElements = [];
+      elements.forEach((el) => {
+        this.intersectionObserver.observe(el);
+        this.observedElements.push(el);
+      });
+    }
+  }
+  stopObserver() {
+    this.intersectionObserver.disconnect();
+  }
+  handleDisabledChange() {
+    if (this.disabled) {
+      this.stopObserver();
+    } else {
+      this.startObserver();
+    }
+  }
+  render() {
+    return html`<slot @slotchange=${this.handleSlotChange}></slot> `;
+  }
+};
+LynkIntersectionObserver.styles = [component_styles_default, intersection_observer_styles_default];
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkIntersectionObserver.prototype, "disabled", 2);
+__decorateClass([
+  watch("disabled", { waitUntilFirstUpdate: true })
+], LynkIntersectionObserver.prototype, "handleDisabledChange", 1);
+
+export {
+  LynkIntersectionObserver
+};

package/dist/chunks/chunk.TNIPHOJB.js

@@ -0,0 +1,21 @@
+import {
+  LynkTr
+} from "./chunk.76QT4YKK.js";
+
+// src/react/tr/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+var tagName = "lynk-tr";
+LynkTr.define("lynk-tr");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkTr,
+  react: React,
+  events: {},
+  displayName: "LynkTr"
+});
+var tr_default = reactWrapper;
+
+export {
+  tr_default
+};