@uplynk/lynk-design 1.19.1 → 1.20.0

package/dist/chunks/chunk.26AJU2IT.js

@@ -0,0 +1,386 @@
+import {
+  split_panel_styles_default
+} from "./chunk.AV4Y3TAX.js";
+import {
+  drag
+} from "./chunk.A4SOQOK5.js";
+import {
+  clamp
+} from "./chunk.HF7GESMZ.js";
+import {
+  LocalizeController
+} from "./chunk.VIBAEA26.js";
+import {
+  watch
+} from "./chunk.SPANRPKG.js";
+import {
+  LynkElement
+} from "./chunk.OVBPFU7N.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.O6LH3WX2.js";
+
+// src/components/split-panel/split-panel.component.ts
+import { html } from "lit";
+import { ifDefined } from "lit/directives/if-defined.js";
+import { property, query } from "lit/decorators.js";
+var SNAP_NONE = () => null;
+var LynkSplitPanel = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.isCollapsed = false;
+    this.localize = new LocalizeController(this);
+    this.positionBeforeCollapsing = 0;
+    this.savedPosition = null;
+    this.position = 50;
+    this.vertical = false;
+    this.disabled = false;
+    // Returned when the property is queried, so that string 'snap's are preserved.
+    this.snapValue = "";
+    // Actually used for computing snap points. All string snaps are converted via `toSnapFunction`.
+    this.snapFunction = SNAP_NONE;
+    this.snapThreshold = 12;
+  }
+  /**
+   * Converts a string containing either a series of fixed/repeated snap points (e.g. "repeat(20%)", "100px 200px 800px", or "10% 50% repeat(10px)") into a SnapFunction. `SnapFunction`s take in a `SnapFunctionOpts` and return the position that the split panel should snap to.
+   *
+   * @param snap - The snap string.
+   * @returns a `SnapFunction` representing the snap string's logic.
+   */
+  toSnapFunction(snap) {
+    const snapPoints = snap.split(" ");
+    return ({ pos, size, snapThreshold, isRtl, vertical }) => {
+      let newPos = pos;
+      let minDistance = Number.POSITIVE_INFINITY;
+      snapPoints.forEach((value) => {
+        let snapPoint;
+        if (value.startsWith("repeat(")) {
+          const repeatVal = snap.substring("repeat(".length, snap.length - 1);
+          const isPercent = repeatVal.endsWith("%");
+          const repeatNum = Number.parseFloat(repeatVal);
+          const snapIntervalPx = isPercent ? size * (repeatNum / 100) : repeatNum;
+          snapPoint = Math.round((isRtl && !vertical ? size - pos : pos) / snapIntervalPx) * snapIntervalPx;
+        } else if (value.endsWith("%")) {
+          snapPoint = size * (Number.parseFloat(value) / 100);
+        } else {
+          snapPoint = Number.parseFloat(value);
+        }
+        if (isRtl && !vertical) {
+          snapPoint = size - snapPoint;
+        }
+        const distance = Math.abs(pos - snapPoint);
+        if (distance <= snapThreshold && distance < minDistance) {
+          newPos = snapPoint;
+          minDistance = distance;
+        }
+      });
+      return newPos;
+    };
+  }
+  set snap(snap) {
+    this.snapValue = snap != null ? snap : "";
+    if (snap) {
+      this.snapFunction = typeof snap === "string" ? this.toSnapFunction(snap) : snap;
+    } else {
+      this.snapFunction = SNAP_NONE;
+    }
+  }
+  get snap() {
+    return this.snapValue;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.loadPosition();
+    this.resizeObserver = new ResizeObserver((entries) => this.handleResize(entries));
+    this.mutationObserver = new MutationObserver(() => this.handleVisibilityChange());
+    this.updateComplete.then(() => {
+      this.resizeObserver.observe(this);
+      this.detectSize();
+      this.cachedPositionInPixels = this.percentageToPixels(this.position);
+      this.setupAutoObservation();
+      setTimeout(() => this.handleVisibilityChange(), 0);
+    });
+  }
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this.resizeObserver) == null ? void 0 : _a.unobserve(this);
+    (_b = this.mutationObserver) == null ? void 0 : _b.disconnect();
+  }
+  detectSize() {
+    const { width, height } = this.getBoundingClientRect();
+    this.size = this.vertical ? height : width;
+  }
+  percentageToPixels(value) {
+    return this.size * (value / 100);
+  }
+  pixelsToPercentage(value) {
+    return value / this.size * 100;
+  }
+  loadPosition() {
+    if (this.autoSaveId && typeof localStorage !== "undefined") {
+      try {
+        const stored = localStorage.getItem(`lynk-split-panel-${this.autoSaveId}`);
+        if (stored && !isNaN(Number(stored))) {
+          this.position = Number(stored);
+        }
+      } catch (e) {
+      }
+    }
+  }
+  savePosition() {
+    if (this.autoSaveId && typeof localStorage !== "undefined") {
+      try {
+        localStorage.setItem(`lynk-split-panel-${this.autoSaveId}`, this.position.toString());
+      } catch (e) {
+      }
+    }
+  }
+  setupAutoObservation() {
+    var _a, _b;
+    this.mutationObserver.observe(this, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["hidden", "style"]
+    });
+    const startSlot = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector('slot[name="start"]');
+    const endSlot = (_b = this.shadowRoot) == null ? void 0 : _b.querySelector('slot[name="end"]');
+    if (startSlot) {
+      startSlot.addEventListener("slotchange", () => this.handleVisibilityChange());
+    }
+    if (endSlot) {
+      endSlot.addEventListener("slotchange", () => this.handleVisibilityChange());
+    }
+  }
+  handleVisibilityChange() {
+    const startElements = this.getSlottedElements("start");
+    const endElements = this.getSlottedElements("end");
+    const startVisible = startElements.some((el) => this.isElementVisible(el));
+    const endVisible = endElements.some((el) => this.isElementVisible(el));
+    if (startVisible && endVisible) {
+      if (this.savedPosition !== null) {
+        this.position = this.savedPosition;
+        this.savedPosition = null;
+      }
+    } else if (startVisible || endVisible) {
+      if (this.savedPosition === null) {
+        this.savedPosition = this.position;
+      }
+    }
+    this.requestUpdate();
+  }
+  getSlottedElements(slotName) {
+    var _a;
+    const slot = (_a = this.shadowRoot) == null ? void 0 : _a.querySelector(`slot[name="${slotName}"]`);
+    return slot ? slot.assignedElements() : [];
+  }
+  isElementVisible(element) {
+    if (element.hasAttribute("hidden")) return false;
+    const style = getComputedStyle(element);
+    return style.display !== "none" && style.visibility !== "hidden";
+  }
+  handleDrag(event) {
+    const isRtl = this.localize.dir() === "rtl";
+    if (this.disabled) {
+      return;
+    }
+    if (event.cancelable) {
+      event.preventDefault();
+    }
+    drag(this, {
+      onMove: (x, y) => {
+        var _a;
+        let newPositionInPixels = this.vertical ? y : x;
+        if (this.primary === "end") {
+          newPositionInPixels = this.size - newPositionInPixels;
+        }
+        newPositionInPixels = (_a = this.snapFunction({
+          pos: newPositionInPixels,
+          size: this.size,
+          snapThreshold: this.snapThreshold,
+          isRtl,
+          vertical: this.vertical
+        })) != null ? _a : newPositionInPixels;
+        this.position = clamp(this.pixelsToPercentage(newPositionInPixels), 0, 100);
+      },
+      initialEvent: event
+    });
+  }
+  handleKeyDown(event) {
+    if (this.disabled) {
+      return;
+    }
+    if (["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Home", "End", "Enter"].includes(event.key)) {
+      let newPosition = this.position;
+      const incr = (event.shiftKey ? 10 : 1) * (this.primary === "end" ? -1 : 1);
+      event.preventDefault();
+      if (event.key === "ArrowLeft" && !this.vertical || event.key === "ArrowUp" && this.vertical) {
+        newPosition -= incr;
+      }
+      if (event.key === "ArrowRight" && !this.vertical || event.key === "ArrowDown" && this.vertical) {
+        newPosition += incr;
+      }
+      if (event.key === "Home") {
+        newPosition = this.primary === "end" ? 100 : 0;
+      }
+      if (event.key === "End") {
+        newPosition = this.primary === "end" ? 0 : 100;
+      }
+      if (event.key === "Enter") {
+        if (this.isCollapsed) {
+          newPosition = this.positionBeforeCollapsing;
+          this.isCollapsed = false;
+        } else {
+          const positionBeforeCollapsing = this.position;
+          newPosition = 0;
+          requestAnimationFrame(() => {
+            this.isCollapsed = true;
+            this.positionBeforeCollapsing = positionBeforeCollapsing;
+          });
+        }
+      }
+      this.position = clamp(newPosition, 0, 100);
+    }
+  }
+  handleResize(entries) {
+    const { width, height } = entries[0].contentRect;
+    this.size = this.vertical ? height : width;
+    if (this.cachedPositionInPixels !== void 0 && (isNaN(this.cachedPositionInPixels) || this.position === Infinity)) {
+      const positionInPixelsAttr = this.getAttribute("position-in-pixels");
+      if (positionInPixelsAttr) {
+        this.cachedPositionInPixels = Number(positionInPixelsAttr);
+        this.positionInPixels = Number(positionInPixelsAttr);
+        this.position = this.pixelsToPercentage(this.positionInPixels);
+      }
+    }
+    if (this.primary && this.cachedPositionInPixels !== void 0) {
+      this.position = this.pixelsToPercentage(this.cachedPositionInPixels);
+    }
+  }
+  handlePositionChange() {
+    this.cachedPositionInPixels = this.percentageToPixels(this.position);
+    this.isCollapsed = false;
+    this.positionBeforeCollapsing = 0;
+    this.positionInPixels = this.percentageToPixels(this.position);
+    this.savePosition();
+    this.emit("ev-reposition");
+  }
+  handlePositionInPixelsChange() {
+    this.position = this.pixelsToPercentage(this.positionInPixels);
+  }
+  handleVerticalChange() {
+    this.detectSize();
+  }
+  render() {
+    const startElements = this.getSlottedElements("start");
+    const endElements = this.getSlottedElements("end");
+    const startVisible = startElements.some((el) => this.isElementVisible(el));
+    const endVisible = endElements.some((el) => this.isElementVisible(el));
+    if (startVisible && !endVisible || !startVisible && endVisible) {
+      this.style.display = "block";
+      this.style.gridTemplateColumns = "";
+      this.style.gridTemplateRows = "";
+      return html`
+        <slot name="start" part="panel start" class="start" style="${startVisible ? "" : "display: none"}"></slot>
+        <slot name="end" part="panel end" class="end" style="${endVisible ? "" : "display: none"}"></slot>
+      `;
+    }
+    this.style.display = "grid";
+    const gridTemplate = this.vertical ? "gridTemplateRows" : "gridTemplateColumns";
+    const gridTemplateAlt = this.vertical ? "gridTemplateColumns" : "gridTemplateRows";
+    const isRtl = this.localize.dir() === "rtl";
+    const primary = `
+      clamp(
+        0%,
+        clamp(
+          var(--min),
+          ${this.position}% - var(--divider-width) / 2,
+          var(--max)
+        ),
+        calc(100% - var(--divider-width))
+      )
+    `;
+    const secondary = "auto";
+    if (this.primary === "end") {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      } else {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      }
+    } else {
+      if (isRtl && !this.vertical) {
+        this.style[gridTemplate] = `${secondary} var(--divider-width) ${primary}`;
+      } else {
+        this.style[gridTemplate] = `${primary} var(--divider-width) ${secondary}`;
+      }
+    }
+    this.style[gridTemplateAlt] = "";
+    return html`
+      <slot name="start" part="panel start" class="start"></slot>
+
+      <div
+        part="divider"
+        class="divider"
+        tabindex=${ifDefined(this.disabled ? void 0 : "0")}
+        role="separator"
+        aria-valuenow=${this.position}
+        aria-valuemin="0"
+        aria-valuemax="100"
+        aria-label=${this.localize.term("resize")}
+        @keydown=${this.handleKeyDown}
+        @mousedown=${this.handleDrag}
+        @touchstart=${this.handleDrag}
+      >
+        <slot name="divider"></slot>
+      </div>
+
+      <slot name="end" part="panel end" class="end"></slot>
+    `;
+  }
+};
+LynkSplitPanel.styles = [component_styles_default, split_panel_styles_default];
+__decorateClass([
+  query(".divider")
+], LynkSplitPanel.prototype, "divider", 2);
+__decorateClass([
+  property({ type: Number, reflect: true })
+], LynkSplitPanel.prototype, "position", 2);
+__decorateClass([
+  property({ attribute: "position-in-pixels", type: Number })
+], LynkSplitPanel.prototype, "positionInPixels", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkSplitPanel.prototype, "vertical", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkSplitPanel.prototype, "disabled", 2);
+__decorateClass([
+  property({ attribute: "auto-save-id" })
+], LynkSplitPanel.prototype, "autoSaveId", 2);
+__decorateClass([
+  property()
+], LynkSplitPanel.prototype, "primary", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkSplitPanel.prototype, "snap", 1);
+__decorateClass([
+  property({ type: Number, attribute: "snap-threshold" })
+], LynkSplitPanel.prototype, "snapThreshold", 2);
+__decorateClass([
+  watch("position")
+], LynkSplitPanel.prototype, "handlePositionChange", 1);
+__decorateClass([
+  watch("positionInPixels")
+], LynkSplitPanel.prototype, "handlePositionInPixelsChange", 1);
+__decorateClass([
+  watch("vertical")
+], LynkSplitPanel.prototype, "handleVerticalChange", 1);
+
+export {
+  SNAP_NONE,
+  LynkSplitPanel
+};

package/dist/chunks/chunk.27O3Z6RL.js

@@ -0,0 +1,11 @@
+import {
+  LynkOption
+} from "./chunk.KLA3UNF4.js";
+
+// src/components/option/option.ts
+var option_default = LynkOption;
+LynkOption.define("lynk-option");
+
+export {
+  option_default
+};

package/dist/chunks/chunk.2DIFALYC.js

@@ -0,0 +1,309 @@
+import {
+  form_control_styles_default
+} from "./chunk.EXYXB64C.js";
+import {
+  defaultValue
+} from "./chunk.GI7VDIWX.js";
+import {
+  checkbox_styles_default
+} from "./chunk.ANWWW5SA.js";
+import {
+  FormControlController
+} from "./chunk.5AIQMNFQ.js";
+import {
+  LynkIcon
+} from "./chunk.JHTDTNM2.js";
+import {
+  HasSlotController
+} from "./chunk.OW5NIGGX.js";
+import {
+  watch
+} from "./chunk.SPANRPKG.js";
+import {
+  LynkElement
+} from "./chunk.OVBPFU7N.js";
+import {
+  component_styles_default
+} from "./chunk.Y7724W4D.js";
+import {
+  __decorateClass
+} from "./chunk.O6LH3WX2.js";
+
+// src/components/checkbox/checkbox.component.ts
+import { html } from "lit";
+import { property, query, state } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { ifDefined } from "lit/directives/if-defined.js";
+import { live } from "lit/directives/live.js";
+var LynkCheckbox = class extends LynkElement {
+  constructor() {
+    super(...arguments);
+    this.formControlController = new FormControlController(this, {
+      value: (control) => control.checked ? control.value || "on" : void 0,
+      defaultValue: (control) => control.defaultChecked,
+      setValue: (control, checked) => control.checked = checked
+    });
+    this.hasSlotController = new HasSlotController(this, "help-text");
+    this.hasLabel = false;
+    this.hasFocus = false;
+    this.title = "";
+    this.name = "";
+    this.size = "medium";
+    this.disabled = false;
+    this.checked = false;
+    this.indeterminate = false;
+    this.defaultChecked = false;
+    this.form = "";
+    this.required = false;
+    this.noBubble = false;
+    this.state = "default";
+    this.helpText = "";
+  }
+  /** Gets the validity state object */
+  get validity() {
+    return this.input.validity;
+  }
+  /** Gets the validation message */
+  get validationMessage() {
+    return this.input.validationMessage;
+  }
+  firstUpdated() {
+    this.formControlController.updateValidity();
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.handleHostClick = this.handleHostClick.bind(this);
+    this.addEventListener("click", this.handleHostClick);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    this.removeEventListener("click", this.handleHostClick);
+  }
+  handleHostClick(event) {
+    if (this.disabled) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+    }
+    if (this.noBubble) {
+      event.stopPropagation();
+    }
+  }
+  handleClick() {
+    this.checked = !this.checked;
+    this.indeterminate = false;
+    this.emit("ev-change", { bubbles: !this.noBubble });
+  }
+  handleBlur() {
+    this.hasFocus = false;
+    this.emit("ev-blur");
+  }
+  handleInput() {
+    this.emit("ev-input");
+  }
+  handleInvalid(event) {
+    this.formControlController.setValidity(false);
+    this.formControlController.emitInvalidEvent(event);
+  }
+  handleFocus() {
+    this.hasFocus = true;
+    this.emit("ev-focus");
+  }
+  handleSlotChange() {
+    const slottedElements = [...this.defaultSlot.assignedNodes({ flatten: true })];
+    if (slottedElements.length) {
+      this.hasLabel = true;
+    } else {
+      this.hasLabel = false;
+    }
+  }
+  handleDisabledChange() {
+    this.formControlController.setValidity(this.disabled);
+  }
+  handleStateChange() {
+    this.input.checked = this.checked;
+    this.input.indeterminate = this.indeterminate;
+    this.formControlController.updateValidity();
+  }
+  /** Simulates a click on the checkbox. */
+  click() {
+    this.input.click();
+  }
+  /** Sets focus on the checkbox. */
+  focus(options) {
+    this.input.focus(options);
+  }
+  /** Removes focus from the checkbox. */
+  blur() {
+    this.input.blur();
+  }
+  /** Checks for validity but does not show a validation message. Returns true when valid and false when invalid. */
+  checkValidity() {
+    return this.input.checkValidity();
+  }
+  /** Gets the associated form, if one exists. */
+  getForm() {
+    return this.formControlController.getForm();
+  }
+  /** Checks for validity and shows a validation message if the control is invalid. */
+  reportValidity() {
+    return this.input.reportValidity();
+  }
+  /**
+   * Sets a custom validation message. The value provided will be shown to the user when the form is submitted. To clear
+   * the custom validation message, call this method with an empty string.
+   */
+  setCustomValidity(message) {
+    this.input.setCustomValidity(message);
+    this.formControlController.updateValidity();
+  }
+  render() {
+    const hasHelpTextSlot = this.hasSlotController.test("help-text");
+    const hasHelpText = this.helpText ? true : !!hasHelpTextSlot;
+    return html`
+      <div
+        class=${classMap({
+      "form-control": true,
+      "form-control--small": this.size === "small",
+      "form-control--medium": this.size === "medium",
+      "form-control--large": this.size === "large",
+      "form-control--has-help-text": hasHelpText
+    })}
+      >
+        <label
+          part="base"
+          class=${classMap({
+      checkbox: true,
+      "checkbox--checked": this.checked,
+      "checkbox--disabled": this.disabled,
+      "checkbox--focused": this.hasFocus,
+      "checkbox--has-label": this.hasLabel,
+      "checkbox--indeterminate": this.indeterminate,
+      "checkbox--small": this.size === "small",
+      "checkbox--medium": this.size === "medium",
+      "checkbox--large": this.size === "large",
+      "checkbox--has-error": this.state === "error" || this.hasAttribute("data-user-invalid"),
+      "checkbox--has-warning": this.state === "warning",
+      "checkbox--has-success": this.state === "success"
+    })}
+        >
+          <input
+            class="checkbox__input"
+            type="checkbox"
+            title=${this.title}
+            name=${this.name}
+            value=${ifDefined(this.value)}
+            .indeterminate=${live(this.indeterminate)}
+            .checked=${live(this.checked)}
+            .disabled=${this.disabled}
+            .required=${this.required}
+            aria-checked=${this.checked ? "true" : "false"}
+            aria-describedby="help-text"
+            @click=${this.handleClick}
+            @input=${this.handleInput}
+            @invalid=${this.handleInvalid}
+            @blur=${this.handleBlur}
+            @focus=${this.handleFocus}
+          />
+
+          <span
+            part="control${this.checked ? " control--checked" : ""}${this.indeterminate ? " control--indeterminate" : ""}"
+            class="checkbox__control"
+          >
+            ${this.checked ? html`
+                    <lynk-icon
+                      part="checked-icon"
+                      class="checkbox__checked-icon"
+                      library="system"
+                      name="check"
+                    ></lynk-icon>
+                  ` : ""}
+            ${!this.checked && this.indeterminate ? html`
+                    <lynk-icon
+                      part="indeterminate-icon"
+                      class="checkbox__indeterminate-icon"
+                      library="system"
+                      name="indeterminate"
+                    ></lynk-icon>
+                  ` : ""}
+          </span>
+
+          <div part="label" class="checkbox__label">
+            <slot @slotchange=${this.handleSlotChange}></slot>
+          </div>
+        </label>
+
+        <div
+          aria-hidden=${hasHelpText ? "false" : "true"}
+          class="form-control__help-text"
+          id="help-text"
+          part="form-control-help-text"
+        >
+          <slot name="help-text">${this.helpText}</slot>
+        </div>
+      </div>
+    `;
+  }
+};
+LynkCheckbox.styles = [component_styles_default, form_control_styles_default, checkbox_styles_default];
+LynkCheckbox.dependencies = { "lynk-icon": LynkIcon };
+__decorateClass([
+  query("slot")
+], LynkCheckbox.prototype, "defaultSlot", 2);
+__decorateClass([
+  query('input[type="checkbox"]')
+], LynkCheckbox.prototype, "input", 2);
+__decorateClass([
+  state()
+], LynkCheckbox.prototype, "hasLabel", 2);
+__decorateClass([
+  state()
+], LynkCheckbox.prototype, "hasFocus", 2);
+__decorateClass([
+  property()
+], LynkCheckbox.prototype, "title", 2);
+__decorateClass([
+  property()
+], LynkCheckbox.prototype, "name", 2);
+__decorateClass([
+  property()
+], LynkCheckbox.prototype, "value", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkCheckbox.prototype, "size", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkCheckbox.prototype, "disabled", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkCheckbox.prototype, "checked", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkCheckbox.prototype, "indeterminate", 2);
+__decorateClass([
+  defaultValue("checked")
+], LynkCheckbox.prototype, "defaultChecked", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkCheckbox.prototype, "form", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], LynkCheckbox.prototype, "required", 2);
+__decorateClass([
+  property({ attribute: "no-bubble", type: Boolean, reflect: true })
+], LynkCheckbox.prototype, "noBubble", 2);
+__decorateClass([
+  property({ reflect: true })
+], LynkCheckbox.prototype, "state", 2);
+__decorateClass([
+  property({ attribute: "help-text" })
+], LynkCheckbox.prototype, "helpText", 2);
+__decorateClass([
+  watch("disabled", { waitUntilFirstUpdate: true })
+], LynkCheckbox.prototype, "handleDisabledChange", 1);
+__decorateClass([
+  watch(["checked", "indeterminate"], { waitUntilFirstUpdate: true })
+], LynkCheckbox.prototype, "handleStateChange", 1);
+
+export {
+  LynkCheckbox
+};