@uplynk/lynk-design 1.15.0 → 1.17.0

package/dist/chunks/chunk.PL65IS3N.js

@@ -0,0 +1,211 @@
+import {
+  animation_styles_default
+} from "./chunk.XVVDUPMB.js";
+import {
+  animations
+} from "./chunk.TJOP7HQP.js";
+import {
+  watch
+} from "./chunk.GQZ7EGMM.js";
+import {
+  LynkElement
+} from "./chunk.V4JS4TJ7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.Q44EX5TP.js";
+
+// src/components/animation/animation.component.ts
+import { html } from "lit";
+import { property, queryAsync } from "lit/decorators.js";
+var LynkAnimation = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.hasStarted = false;
+    this.name = "none";
+    this.play = false;
+    this.delay = 0;
+    this.direction = "normal";
+    this.duration = 1e3;
+    this.easing = "linear";
+    this.endDelay = 0;
+    this.fill = "auto";
+    this.iterations = Infinity;
+    this.iterationStart = 0;
+    this.playbackRate = 1;
+    this.handleAnimationFinish = () => {
+      this.play = false;
+      this.hasStarted = false;
+      this.emit("ev-finish");
+    };
+    this.handleAnimationCancel = () => {
+      this.play = false;
+      this.hasStarted = false;
+      this.emit("ev-cancel");
+    };
+  }
+  /** Gets and sets the current animation time. */
+  get currentTime() {
+    var _a, _b;
+    return (_b = (_a = this.animation) == null ? void 0 : _a.currentTime) != null ? _b : 0;
+  }
+  set currentTime(time) {
+    if (this.animation) {
+      this.animation.currentTime = time;
+    }
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.createAnimation();
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.destroyAnimation();
+  }
+  handleSlotChange() {
+    this.destroyAnimation();
+    this.createAnimation();
+  }
+  async createAnimation() {
+    var _a, _b;
+    const easing = (_a = animations.easings[this.easing]) != null ? _a : this.easing;
+    const keyframes = (_b = this.keyframes) != null ? _b : animations[this.name];
+    const slot = await this.defaultSlot;
+    const element = slot.assignedElements()[0];
+    if (!element || !keyframes) {
+      return false;
+    }
+    this.destroyAnimation();
+    this.animation = element.animate(keyframes, {
+      delay: this.delay,
+      direction: this.direction,
+      duration: this.duration,
+      easing,
+      endDelay: this.endDelay,
+      fill: this.fill,
+      iterationStart: this.iterationStart,
+      iterations: this.iterations
+    });
+    this.animation.playbackRate = this.playbackRate;
+    this.animation.addEventListener("cancel", this.handleAnimationCancel);
+    this.animation.addEventListener("finish", this.handleAnimationFinish);
+    if (this.play) {
+      this.hasStarted = true;
+      this.emit("ev-start");
+    } else {
+      this.animation.pause();
+    }
+    return true;
+  }
+  destroyAnimation() {
+    if (this.animation) {
+      this.animation.cancel();
+      this.animation.removeEventListener("cancel", this.handleAnimationCancel);
+      this.animation.removeEventListener("finish", this.handleAnimationFinish);
+      this.hasStarted = false;
+    }
+  }
+  handleAnimationChange() {
+    if (!this.hasUpdated) {
+      return;
+    }
+    this.createAnimation();
+  }
+  handlePlayChange() {
+    if (this.animation) {
+      if (this.play && !this.hasStarted) {
+        this.hasStarted = true;
+        this.emit("ev-start");
+      }
+      if (this.play) {
+        this.animation.play();
+      } else {
+        this.animation.pause();
+      }
+      return true;
+    }
+    return false;
+  }
+  handlePlaybackRateChange() {
+    if (this.animation) {
+      this.animation.playbackRate = this.playbackRate;
+    }
+  }
+  /** Clears all KeyframeEffects caused by this animation and aborts its playback. */
+  cancel() {
+    var _a;
+    (_a = this.animation) == null ? void 0 : _a.cancel();
+  }
+  /** Sets the playback time to the end of the animation corresponding to the current playback direction. */
+  finish() {
+    var _a;
+    (_a = this.animation) == null ? void 0 : _a.finish();
+  }
+  render() {
+    return html` <slot @slotchange=${this.handleSlotChange}></slot> `;
+  }
+};
+LynkAnimation.styles = [component_styles_default, animation_styles_default];
+__decorateClass([
+  queryAsync("slot")
+], LynkAnimation.prototype, "defaultSlot", 2);
+__decorateClass([
+  property()
+], LynkAnimation.prototype, "name", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkAnimation.prototype, "play", 2);
+__decorateClass([
+  property({ type: Number })
+], LynkAnimation.prototype, "delay", 2);
+__decorateClass([
+  property()
+], LynkAnimation.prototype, "direction", 2);
+__decorateClass([
+  property({ type: Number })
+], LynkAnimation.prototype, "duration", 2);
+__decorateClass([
+  property()
+], LynkAnimation.prototype, "easing", 2);
+__decorateClass([
+  property({ attribute: "end-delay", type: Number })
+], LynkAnimation.prototype, "endDelay", 2);
+__decorateClass([
+  property()
+], LynkAnimation.prototype, "fill", 2);
+__decorateClass([
+  property({ type: Number })
+], LynkAnimation.prototype, "iterations", 2);
+__decorateClass([
+  property({ attribute: "iteration-start", type: Number })
+], LynkAnimation.prototype, "iterationStart", 2);
+__decorateClass([
+  property({ attribute: false })
+], LynkAnimation.prototype, "keyframes", 2);
+__decorateClass([
+  property({ attribute: "playback-rate", type: Number })
+], LynkAnimation.prototype, "playbackRate", 2);
+__decorateClass([
+  watch("name"),
+  watch("delay"),
+  watch("direction"),
+  watch("duration"),
+  watch("easing"),
+  watch("endDelay"),
+  watch("fill"),
+  watch("iterations"),
+  watch("iterationsStart"),
+  watch("keyframes")
+], LynkAnimation.prototype, "handleAnimationChange", 1);
+__decorateClass([
+  watch("play")
+], LynkAnimation.prototype, "handlePlayChange", 1);
+__decorateClass([
+  watch("playbackRate")
+], LynkAnimation.prototype, "handlePlaybackRateChange", 1);
+
+export {
+  LynkAnimation
+};

package/dist/chunks/chunk.POMLEX4E.js

@@ -0,0 +1,277 @@
+import {
+  tooltip_styles_default
+} from "./chunk.FGRWDPVX.js";
+import {
+  LynkPopup
+} from "./chunk.DWZDRSAO.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.V4JS4TJ7.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.POT2WWNU.js

@@ -0,0 +1,61 @@
+import {
+  page_header_styles_default
+} from "./chunk.XDFCUAHU.js";
+import {
+  LynkPageContent
+} from "./chunk.7O2SPDRQ.js";
+import {
+  LynkPage
+} from "./chunk.AMWOIUPK.js";
+import {
+  LynkElement
+} from "./chunk.V4JS4TJ7.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.Q44EX5TP.js";
+
+// src/components/page-header/page-header.component.ts
+import { html } from "lit";
+import { property } from "lit/decorators.js";
+var LynkPageHeader = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.width = "fluid";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (!this.slot && this.hasParentLayout()) {
+      this.slot = "header";
+    }
+  }
+  // Checks whether the heading is nested into a lynk-page
+  hasParentLayout() {
+    const parent = this.parentElement;
+    return parent instanceof LynkPage;
+  }
+  render() {
+    return html`
+      <lynk-page-content width="${this.width}" style="--padding-top: 0; --padding-bottom: 0;">
+        <header part="base" class="page-header">
+          <slot name="breadcrumb" part="breadcrumb" class="page-header__breadcrumb"></slot>
+          <slot name="aux" part="aux" class="page-header__aux"></slot>
+          <slot class="page-header__main"></slot>
+          <slot name="controls" part="controls" class="page-header__controls"></slot>
+          <slot name="tabs" part="tabs" class="page-header__tabs"></slot>
+        </header>
+      </lynk-page-content>
+    `;
+  }
+};
+LynkPageHeader.styles = [component_styles_default, page_header_styles_default];
+LynkPageHeader.dependencies = { "lynk-page-content": LynkPageContent, "lynk-page": LynkPage };
+__decorateClass([
+  property({ reflect: true })
+], LynkPageHeader.prototype, "width", 2);
+
+export {
+  LynkPageHeader
+};

package/dist/chunks/chunk.PZPZDOOT.js

@@ -0,0 +1,27 @@
+import {
+  LynkTooltip
+} from "./chunk.POMLEX4E.js";
+
+// src/react/tooltip/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-tooltip";
+LynkTooltip.define("lynk-tooltip");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkTooltip,
+  react: React,
+  events: {
+    EvShow: "ev-show",
+    EvAfterShow: "ev-after-show",
+    EvHide: "ev-hide",
+    EvAfterHide: "ev-after-hide"
+  },
+  displayName: "LynkTooltip"
+});
+var tooltip_default = reactWrapper;
+
+export {
+  tooltip_default
+};

package/dist/chunks/chunk.Q2CZPZI5.js

@@ -0,0 +1,27 @@
+import {
+  LynkDropdown
+} from "./chunk.56FN6S3X.js";
+
+// src/react/dropdown/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-dropdown";
+LynkDropdown.define("lynk-dropdown");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkDropdown,
+  react: React,
+  events: {
+    EvShow: "ev-show",
+    EvAfterShow: "ev-after-show",
+    EvHide: "ev-hide",
+    EvAfterHide: "ev-after-hide"
+  },
+  displayName: "LynkDropdown"
+});
+var dropdown_default = reactWrapper;
+
+export {
+  dropdown_default
+};

package/dist/chunks/chunk.QBQIZ4PS.js

@@ -0,0 +1,25 @@
+import {
+  LynkCopyButton
+} from "./chunk.BBWSQHHF.js";
+
+// src/react/copy-button/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-copy-button";
+LynkCopyButton.define("lynk-copy-button");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkCopyButton,
+  react: React,
+  events: {
+    EvCopy: "ev-copy",
+    EvError: "ev-error"
+  },
+  displayName: "LynkCopyButton"
+});
+var copy_button_default = reactWrapper;
+
+export {
+  copy_button_default
+};

package/dist/chunks/chunk.QO4W24EE.js

@@ -0,0 +1,28 @@
+import {
+  LynkRange
+} from "./chunk.E5LFWUT6.js";
+
+// src/react/range/index.ts
+import * as React from "react";
+import { createComponent } from "@lit/react";
+import "@lit/react";
+var tagName = "lynk-range";
+LynkRange.define("lynk-range");
+var reactWrapper = createComponent({
+  tagName,
+  elementClass: LynkRange,
+  react: React,
+  events: {
+    EvBlur: "ev-blur",
+    EvChange: "ev-change",
+    EvFocus: "ev-focus",
+    EvInput: "ev-input",
+    EvInvalid: "ev-invalid"
+  },
+  displayName: "LynkRange"
+});
+var range_default = reactWrapper;
+
+export {
+  range_default
+};