@uplynk/lynk-design 1.11.3 → 1.12.1

package/cdn/chunks/chunk.LWWRQCOA.js

@@ -0,0 +1,282 @@
+import {
+  tooltip_styles_default
+} from "./chunk.S5TDKPJX.js";
+import {
+  LynkPopup
+} from "./chunk.JCE7Q7O2.js";
+import {
+  waitForEvent
+} from "./chunk.B4BZKR24.js";
+import {
+  animateTo,
+  parseDuration,
+  stopAnimations
+} from "./chunk.ONECFZZX.js";
+import {
+  getAnimation,
+  setDefaultAnimation
+} from "./chunk.JSLXCIMZ.js";
+import {
+  LocalizeController
+} from "./chunk.VS2OBD6I.js";
+import {
+  watch
+} from "./chunk.RB5L7E7Z.js";
+import {
+  e
+} from "./chunk.BB43Q4ZV.js";
+import {
+  LynkElement,
+  e as e2,
+  n
+} from "./chunk.RWJTJO4F.js";
+import {
+  component_styles_default
+} from "./chunk.ADWNFIQR.js";
+import {
+  x
+} from "./chunk.BW3AXSF6.js";
+import {
+  __decorateClass
+} from "./chunk.QIOX6AG5.js";
+
+// src/components/tooltip/tooltip.component.ts
+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 x`
+      <lynk-popup
+        part="base"
+        exportparts="
+          popup:base__popup,
+          arrow:base__arrow
+        "
+        class=${e({
+      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([
+  e2("slot:not([name])")
+], LynkTooltip.prototype, "defaultSlot", 2);
+__decorateClass([
+  e2(".tooltip__body")
+], LynkTooltip.prototype, "body", 2);
+__decorateClass([
+  e2("lynk-popup")
+], LynkTooltip.prototype, "popup", 2);
+__decorateClass([
+  n()
+], LynkTooltip.prototype, "content", 2);
+__decorateClass([
+  n()
+], LynkTooltip.prototype, "placement", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], LynkTooltip.prototype, "disabled", 2);
+__decorateClass([
+  n({ type: Number })
+], LynkTooltip.prototype, "distance", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], LynkTooltip.prototype, "open", 2);
+__decorateClass([
+  n({ type: Number })
+], LynkTooltip.prototype, "skidding", 2);
+__decorateClass([
+  n({ attribute: "no-arrow", type: Boolean, reflect: true })
+], LynkTooltip.prototype, "noArrow", 2);
+__decorateClass([
+  n()
+], LynkTooltip.prototype, "trigger", 2);
+__decorateClass([
+  n({ 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/cdn/chunks/chunk.LYL4TNDN.js

@@ -0,0 +1,64 @@
+import {
+  badge_styles_default
+} from "./chunk.NTPIJXX5.js";
+import {
+  e
+} from "./chunk.BB43Q4ZV.js";
+import {
+  LynkElement,
+  n
+} from "./chunk.RWJTJO4F.js";
+import {
+  component_styles_default
+} from "./chunk.ADWNFIQR.js";
+import {
+  x
+} from "./chunk.BW3AXSF6.js";
+import {
+  __decorateClass
+} from "./chunk.QIOX6AG5.js";
+
+// src/components/badge/badge.component.ts
+var LynkBadge = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.pill = false;
+    this.pulse = false;
+  }
+  render() {
+    return x`
+      <span
+        part="base"
+        class=${e({
+      badge: true,
+      "badge--primary": this.type === "primary",
+      "badge--accent": this.type === "accent",
+      "badge--info": this.type === "info",
+      "badge--success": this.type === "success",
+      "badge--neutral": this.type === "neutral",
+      "badge--warning": this.type === "warning",
+      "badge--danger": this.type === "danger",
+      "badge--pill": this.pill,
+      "badge--pulse": this.pulse
+    })}
+        role="status"
+      >
+        <slot></slot>
+      </span>
+    `;
+  }
+};
+LynkBadge.styles = [component_styles_default, badge_styles_default];
+__decorateClass([
+  n({ reflect: true })
+], LynkBadge.prototype, "type", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], LynkBadge.prototype, "pill", 2);
+__decorateClass([
+  n({ type: Boolean, reflect: true })
+], LynkBadge.prototype, "pulse", 2);
+
+export {
+  LynkBadge
+};

package/cdn/chunks/chunk.LZU5GBSM.js

@@ -0,0 +1,83 @@
+import {
+  LynkPage
+} from "./chunk.ZB2ZOK3S.js";
+import {
+  page_content_styles_default
+} from "./chunk.DTU7JG3G.js";
+import {
+  getScrollParent
+} from "./chunk.WSPFGNPB.js";
+import {
+  HasSlotController
+} from "./chunk.OW5NIGGX.js";
+import {
+  e
+} from "./chunk.BB43Q4ZV.js";
+import {
+  LynkElement,
+  e as e2,
+  n
+} from "./chunk.RWJTJO4F.js";
+import {
+  component_styles_default
+} from "./chunk.ADWNFIQR.js";
+import {
+  x
+} from "./chunk.BW3AXSF6.js";
+import {
+  __decorateClass
+} from "./chunk.QIOX6AG5.js";
+
+// src/components/page-content/page-content.component.ts
+var LynkPageContent = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.hasSlotController = new HasSlotController(this, "header");
+    this.width = "fluid";
+  }
+  /** Scrolls the nearest scrollable parent element to the top. */
+  scrollToTop() {
+    const parent = this.hasParentLayout() ? this.parentElement.renderRoot.querySelector(".page__main") : getScrollParent(this.pageContent);
+    if (parent) {
+      parent.scrollTo({ top: 0, behavior: "smooth" });
+    }
+  }
+  // Checks whether the page content is nested into a lynk-page
+  hasParentLayout() {
+    const parent = this.parentElement;
+    return parent instanceof LynkPage;
+  }
+  render() {
+    return x`
+      <div
+        part="base"
+        class=${e({
+      "page-content": true,
+      "page-content--auto": this.width === "auto",
+      "page-content--sm": this.width === "small",
+      "page-content--md": this.width === "medium",
+      "page-content--lg": this.width === "large",
+      "page-content--xl": this.width === "x-large",
+      "page-content--xxl": this.width === "2x-large",
+      "page-content--fluid": this.width === "fluid",
+      "page-content--has-header": this.hasSlotController.test("header")
+    })}
+      >
+        ${this.hasSlotController.test("header") ? x`<slot name="header" part="header" class="page-content__header"></slot>` : ""}
+        <slot part="main" class="page-content__main"></slot>
+      </div>
+    `;
+  }
+};
+LynkPageContent.styles = [component_styles_default, page_content_styles_default];
+LynkPageContent.dependencies = { "lynk-page": LynkPage };
+__decorateClass([
+  n({ reflect: true })
+], LynkPageContent.prototype, "width", 2);
+__decorateClass([
+  e2(".page-content")
+], LynkPageContent.prototype, "pageContent", 2);
+
+export {
+  LynkPageContent
+};

package/cdn/chunks/chunk.M3JPTEQZ.js

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

package/cdn/chunks/chunk.MAZDRTDT.js

@@ -0,0 +1,57 @@
+import {
+  responsive_media_styles_default
+} from "./chunk.EGLRCU2T.js";
+import {
+  e
+} from "./chunk.BB43Q4ZV.js";
+import {
+  LynkElement,
+  n
+} from "./chunk.RWJTJO4F.js";
+import {
+  component_styles_default
+} from "./chunk.ADWNFIQR.js";
+import {
+  x
+} from "./chunk.BW3AXSF6.js";
+import {
+  __decorateClass
+} from "./chunk.QIOX6AG5.js";
+
+// src/components/responsive-media/responsive-media.component.ts
+var LynkResponsiveMedia = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.aspectRatio = "16:9";
+    this.fit = "cover";
+  }
+  render() {
+    const split = this.aspectRatio.split(":");
+    const x2 = parseFloat(split[0]);
+    const y = parseFloat(split[1]);
+    const paddingBottom = !isNaN(x2) && !isNaN(y) && x2 > 0 && y > 0 ? `${y / x2 * 100}%` : "0";
+    return x`
+      <div
+        class=${e({
+      "responsive-media": true,
+      "responsive-media--cover": this.fit === "cover",
+      "responsive-media--contain": this.fit === "contain"
+    })}
+        style="padding-bottom: ${paddingBottom}"
+      >
+        <slot></slot>
+      </div>
+    `;
+  }
+};
+LynkResponsiveMedia.styles = [component_styles_default, responsive_media_styles_default];
+__decorateClass([
+  n({ attribute: "aspect-ratio" })
+], LynkResponsiveMedia.prototype, "aspectRatio", 2);
+__decorateClass([
+  n()
+], LynkResponsiveMedia.prototype, "fit", 2);
+
+export {
+  LynkResponsiveMedia
+};