@sebgroup/green-core 1.15.0 → 1.16.0

package/chunks/chunk.WJDR7FTS.js

@@ -0,0 +1,193 @@
+import {
+  watch
+} from "./chunk.2WO4NHJ2.js";
+import {
+  gdsCustomElement,
+  html
+} from "./chunk.VOYMQ322.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk.5VURDMKE.js";
+
+// libs/core/src/components/datepicker/date-part-spinner.ts
+import { LitElement } from "lit";
+import { property, state } from "lit/decorators.js";
+var _inputBuffer, _increment, _decrement, _handleClick, _handleFocus, _handleBlur, _handleWheel, _handleKeyDown, _focusNextSpinner, focusNextSpinner_fn, _dispatchChangeEvent, dispatchChangeEvent_fn, _formatNumber, formatNumber_fn, _clamp, clamp_fn, _clearInputBuffer, clearInputBuffer_fn;
+var GdsDatePartSpinner = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _focusNextSpinner);
+    __privateAdd(this, _dispatchChangeEvent);
+    __privateAdd(this, _formatNumber);
+    __privateAdd(this, _clamp);
+    __privateAdd(this, _clearInputBuffer);
+    this.value = 0;
+    this.length = 2;
+    this.min = 0;
+    this.max = Number.MAX_SAFE_INTEGER;
+    this.displayValue = __privateMethod(this, _formatNumber, formatNumber_fn).call(this, this.value, this.length);
+    __privateAdd(this, _inputBuffer, "");
+    __privateAdd(this, _increment, () => {
+      let current = parseInt(this.value.toString());
+      if (Number.isNaN(current))
+        current = this.length === 2 ? this.min : (/* @__PURE__ */ new Date()).getFullYear() - 1;
+      this.value = __privateMethod(this, _clamp, clamp_fn).call(this, current + 1);
+      __privateMethod(this, _dispatchChangeEvent, dispatchChangeEvent_fn).call(this);
+    });
+    __privateAdd(this, _decrement, () => {
+      let current = parseInt(this.value.toString());
+      if (Number.isNaN(current))
+        current = this.length === 2 ? this.max : (/* @__PURE__ */ new Date()).getFullYear() + 1;
+      this.value = __privateMethod(this, _clamp, clamp_fn).call(this, current - 1);
+      __privateMethod(this, _dispatchChangeEvent, dispatchChangeEvent_fn).call(this);
+    });
+    __privateAdd(this, _handleClick, (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+      this.focus();
+    });
+    __privateAdd(this, _handleFocus, () => {
+      __privateMethod(this, _clearInputBuffer, clearInputBuffer_fn).call(this);
+    });
+    __privateAdd(this, _handleBlur, () => {
+      if (__privateGet(this, _inputBuffer) === "")
+        return;
+      __privateMethod(this, _clearInputBuffer, clearInputBuffer_fn).call(this);
+      this.value = __privateMethod(this, _clamp, clamp_fn).call(this, parseInt(this.value.toString()));
+      __privateMethod(this, _dispatchChangeEvent, dispatchChangeEvent_fn).call(this);
+    });
+    __privateAdd(this, _handleWheel, (e) => {
+      e.stopPropagation();
+      e.preventDefault();
+      if (e.deltaY > 0) {
+        __privateGet(this, _decrement).call(this);
+      } else {
+        __privateGet(this, _increment).call(this);
+      }
+    });
+    __privateAdd(this, _handleKeyDown, (e) => {
+      let handled = false;
+      if (e.key === "ArrowUp") {
+        __privateGet(this, _increment).call(this);
+        handled = true;
+      } else if (e.key === "ArrowDown") {
+        __privateGet(this, _decrement).call(this);
+        handled = true;
+      } else {
+        const key = parseInt(e.key);
+        if (!isNaN(key)) {
+          if (__privateGet(this, _inputBuffer).length < this.length) {
+            __privateSet(this, _inputBuffer, __privateGet(this, _inputBuffer) + key.toString());
+            this.value = parseInt(__privateGet(this, _inputBuffer));
+          }
+          if (__privateGet(this, _inputBuffer).length === this.length) {
+            this.value = __privateMethod(this, _clamp, clamp_fn).call(this, this.value);
+            __privateMethod(this, _clearInputBuffer, clearInputBuffer_fn).call(this);
+            __privateMethod(this, _focusNextSpinner, focusNextSpinner_fn).call(this);
+            __privateMethod(this, _dispatchChangeEvent, dispatchChangeEvent_fn).call(this);
+          }
+          handled = true;
+        }
+      }
+      if (handled) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    });
+  }
+  // No need for a shadow root here
+  createRenderRoot() {
+    return this;
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("role", "spinbutton");
+    this.setAttribute("tabindex", "0");
+    this.addEventListener("wheel", __privateGet(this, _handleWheel));
+    this.addEventListener("keydown", __privateGet(this, _handleKeyDown));
+    this.addEventListener("blur", __privateGet(this, _handleBlur));
+    this.addEventListener("focus", __privateGet(this, _handleFocus));
+    this.addEventListener("click", __privateGet(this, _handleClick));
+    this.addEventListener("mousedown", __privateGet(this, _handleClick));
+  }
+  focus(options) {
+    super.focus(options);
+    __privateGet(this, _handleFocus).call(this);
+  }
+  render() {
+    return html`${this.displayValue}`;
+  }
+  _refreshDisplayValue() {
+    this.displayValue = __privateMethod(this, _formatNumber, formatNumber_fn).call(this, this.value, this.length);
+    this.setAttribute("aria-valuetext", this.value.toString());
+  }
+};
+_inputBuffer = new WeakMap();
+_increment = new WeakMap();
+_decrement = new WeakMap();
+_handleClick = new WeakMap();
+_handleFocus = new WeakMap();
+_handleBlur = new WeakMap();
+_handleWheel = new WeakMap();
+_handleKeyDown = new WeakMap();
+_focusNextSpinner = new WeakSet();
+focusNextSpinner_fn = function() {
+  let nextSpinner = this.nextElementSibling;
+  while (nextSpinner) {
+    if (nextSpinner instanceof GdsDatePartSpinner) {
+      nextSpinner.focus();
+      break;
+    }
+    nextSpinner = nextSpinner.nextElementSibling;
+  }
+};
+_dispatchChangeEvent = new WeakSet();
+dispatchChangeEvent_fn = function() {
+  this.dispatchEvent(
+    new CustomEvent("change", {
+      detail: { value: this.value.toString() }
+    })
+  );
+};
+_formatNumber = new WeakSet();
+formatNumber_fn = function(num, padZeros) {
+  return String(num).padStart(padZeros, "0");
+};
+_clamp = new WeakSet();
+clamp_fn = function(value) {
+  return Math.max(this.min, Math.min(this.max, value));
+};
+_clearInputBuffer = new WeakSet();
+clearInputBuffer_fn = function() {
+  __privateSet(this, _inputBuffer, "");
+};
+GdsDatePartSpinner.formAssociated = true;
+__decorateClass([
+  property({ type: Number })
+], GdsDatePartSpinner.prototype, "value", 2);
+__decorateClass([
+  property({ type: Number })
+], GdsDatePartSpinner.prototype, "length", 2);
+__decorateClass([
+  property({ type: Number, attribute: "aria-valuemin" })
+], GdsDatePartSpinner.prototype, "min", 2);
+__decorateClass([
+  property({ type: Number, attribute: "aria-valuemax" })
+], GdsDatePartSpinner.prototype, "max", 2);
+__decorateClass([
+  state()
+], GdsDatePartSpinner.prototype, "displayValue", 2);
+__decorateClass([
+  watch("value")
+], GdsDatePartSpinner.prototype, "_refreshDisplayValue", 1);
+GdsDatePartSpinner = __decorateClass([
+  gdsCustomElement("gds-date-part-spinner")
+], GdsDatePartSpinner);
+
+export {
+  GdsDatePartSpinner
+};

package/chunks/chunk.WM7HBMMV.js

@@ -0,0 +1,54 @@
+// libs/core/src/utils/decorators/observe-light-dom.ts
+function observeLightDOM(observerConfig = {
+  attributes: true,
+  childList: true,
+  subtree: false,
+  characterData: true
+}) {
+  return (proto, _propertyKey, descriptor) => {
+    let observer;
+    const connectedCallback = proto.connectedCallback;
+    const disconnectedCallback = proto.disconnectedCallback;
+    proto.connectedCallback = function() {
+      connectedCallback == null ? void 0 : connectedCallback.call(this);
+      const callback = (_mutationList, _observer) => {
+        var _a;
+        (_a = descriptor.value) == null ? void 0 : _a.call(this);
+      };
+      observer = new MutationObserver(callback);
+      observer.observe(this, observerConfig);
+    };
+    proto.disconnectedCallback = function() {
+      disconnectedCallback == null ? void 0 : disconnectedCallback.call(this);
+      observer.disconnect();
+    };
+  };
+}
+
+// libs/core/src/utils/decorators/watch-media-query.ts
+function watchMediaQuery(q) {
+  return (proto, _propertyKey, descriptor) => {
+    const mediaQuery = window.matchMedia(q);
+    const connectedCallback = proto.connectedCallback;
+    const disconnectedCallback = proto.disconnectedCallback;
+    proto.connectedCallback = function() {
+      var _a;
+      connectedCallback == null ? void 0 : connectedCallback.call(this);
+      const listener = (e) => {
+        var _a2;
+        (_a2 = descriptor.value) == null ? void 0 : _a2.call(this, e.matches);
+      };
+      mediaQuery.addEventListener("change", listener);
+      this.disconnectedCallback = function() {
+        disconnectedCallback == null ? void 0 : disconnectedCallback.call(this);
+        mediaQuery.removeEventListener("change", listener);
+      };
+      (_a = descriptor.value) == null ? void 0 : _a.call(this, mediaQuery.matches);
+    };
+  };
+}
+
+export {
+  observeLightDOM,
+  watchMediaQuery
+};

package/chunks/chunk.XHTJVQUJ.js

@@ -0,0 +1,140 @@
+import {
+  Focusable,
+  option_styles_default
+} from "./chunk.2ND5EWHE.js";
+import {
+  TransitionalStyles
+} from "./chunk.QONSFT2N.js";
+import {
+  GdsElement
+} from "./chunk.2LQSDOD4.js";
+import {
+  watch
+} from "./chunk.2WO4NHJ2.js";
+import {
+  gdsCustomElement
+} from "./chunk.VOYMQ322.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet
+} from "./chunk.5VURDMKE.js";
+
+// libs/core/src/primitives/listbox/option.ts
+import { html } from "lit";
+import { property, state } from "lit/decorators.js";
+import { when } from "lit/directives/when.js";
+import { classMap } from "lit/directives/class-map.js";
+import "reflect-metadata";
+var _hidden, _emitSelect, emitSelect_fn;
+var GdsOption = class extends Focusable(GdsElement) {
+  constructor() {
+    super();
+    __privateAdd(this, _emitSelect);
+    __privateAdd(this, _hidden, false);
+    this.selected = false;
+    this.isPlaceholder = false;
+    this.addEventListener("click", __privateMethod(this, _emitSelect, emitSelect_fn));
+    this.addEventListener("keydown", (e) => {
+      if (e.key !== "Enter" && e.key !== " ")
+        return;
+      e.preventDefault();
+      __privateMethod(this, _emitSelect, emitSelect_fn).call(this, e);
+    });
+  }
+  get hidden() {
+    return __privateGet(this, _hidden);
+  }
+  set hidden(value) {
+    if (this.isPlaceholder)
+      return;
+    __privateSet(this, _hidden, value === "true" || value === true);
+    this.setAttribute("aria-hidden", value.toString());
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("role", "option");
+    if (this.isPlaceholder) {
+      __privateSet(this, _hidden, true);
+      this.setAttribute("aria-hidden", "true");
+    }
+    this.updateComplete.then(
+      () => TransitionalStyles.instance.apply(this, "gds-option")
+    );
+  }
+  get parentElement() {
+    return super.parentElement;
+  }
+  _handlePlaceholderStatusChange() {
+    if (this.isPlaceholder) {
+      __privateSet(this, _hidden, true);
+      this.setAttribute("aria-hidden", "true");
+    } else {
+      __privateSet(this, _hidden, false);
+      this.setAttribute("aria-hidden", "false");
+    }
+  }
+  render() {
+    var _a;
+    const isMultiple = (_a = this.parentElement) == null ? void 0 : _a.multiple;
+    const checkbox = html` <span
+      class="checkbox ${classMap({ checked: this.selected })}"
+    ></span>`;
+    if (!isMultiple) {
+      if (this.selected)
+        this.setAttribute("highlighted", "");
+      else
+        this.removeAttribute("highlighted");
+    }
+    return html`${this._tStyles}
+      <div>${when(isMultiple, () => checkbox)} <slot></slot></div>`;
+  }
+};
+_hidden = new WeakMap();
+_emitSelect = new WeakSet();
+emitSelect_fn = function(e) {
+  e.stopPropagation();
+  this.dispatchEvent(
+    new CustomEvent("gds-select", {
+      bubbles: true,
+      composed: true,
+      detail: {
+        value: this.value
+      }
+    })
+  );
+};
+GdsOption.styles = option_styles_default;
+__decorateClass([
+  property()
+], GdsOption.prototype, "value", 2);
+__decorateClass([
+  property({
+    attribute: "aria-hidden",
+    reflect: true
+  })
+], GdsOption.prototype, "hidden", 1);
+__decorateClass([
+  property({
+    attribute: "aria-selected",
+    reflect: true
+  })
+], GdsOption.prototype, "selected", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], GdsOption.prototype, "isPlaceholder", 2);
+__decorateClass([
+  state()
+], GdsOption.prototype, "_tStyles", 2);
+__decorateClass([
+  watch("isplaceholder")
+], GdsOption.prototype, "_handlePlaceholderStatusChange", 1);
+GdsOption = __decorateClass([
+  gdsCustomElement("gds-option")
+], GdsOption);
+
+export {
+  GdsOption
+};

package/chunks/chunk.XI4H54TV.js

@@ -0,0 +1,39 @@
+import {
+  TransitionalStyles
+} from "./chunk.QONSFT2N.js";
+import {
+  GdsElement
+} from "./chunk.2LQSDOD4.js";
+import {
+  gdsCustomElement,
+  html
+} from "./chunk.VOYMQ322.js";
+import {
+  __decorateClass
+} from "./chunk.5VURDMKE.js";
+
+// libs/core/src/components/theme/theme.ts
+import { property } from "lit/decorators.js";
+var GdsTheme = class extends GdsElement {
+  constructor() {
+    super(...arguments);
+    this.colorScheme = "light";
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    TransitionalStyles.instance.apply(this, "gds-theme");
+  }
+  render() {
+    return html` <slot></slot> `;
+  }
+};
+__decorateClass([
+  property({ reflect: true, attribute: "color-scheme" })
+], GdsTheme.prototype, "colorScheme", 2);
+GdsTheme = __decorateClass([
+  gdsCustomElement("gds-theme")
+], GdsTheme);
+
+export {
+  GdsTheme
+};

package/chunks/chunk.YIQIH4RW.js

@@ -0,0 +1,139 @@
+import {
+  GdsElement
+} from "./chunk.2LQSDOD4.js";
+import {
+  watch
+} from "./chunk.2WO4NHJ2.js";
+import {
+  __decorateClass,
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk.5VURDMKE.js";
+
+// libs/core/src/components/form-control.ts
+import { property } from "lit/decorators.js";
+var _internals;
+var GdsFormControlElement = class extends GdsElement {
+  constructor() {
+    super();
+    __privateAdd(this, _internals, void 0);
+    this.invalid = false;
+    this.name = "";
+    /**
+     * Event handler for the form reset event.
+     * Can be overridden by subclasses to rcustomize the reset value.
+     */
+    this._handleFormReset = () => {
+      this.value = void 0;
+    };
+    try {
+      __privateSet(this, _internals, this.attachInternals());
+    } catch (e) {
+      __privateSet(this, _internals, {
+        form: this.closest("form"),
+        setFormValue: (value) => {
+          this.value = value;
+        },
+        setValidity: (validity, validationMessage) => {
+          this.invalid = validity.customError;
+        },
+        validationMessage: "",
+        validity: {
+          badInput: false,
+          customError: false,
+          patternMismatch: false,
+          rangeOverflow: false,
+          rangeUnderflow: false,
+          stepMismatch: false,
+          tooLong: false,
+          tooShort: false,
+          typeMismatch: false,
+          valueMissing: false,
+          valid: true
+        },
+        willValidate: true,
+        checkValidity: () => true,
+        reportValidity: () => true
+      });
+    }
+  }
+  get form() {
+    return __privateGet(this, _internals).form;
+  }
+  get validity() {
+    return __privateGet(this, _internals).validity;
+  }
+  get validationMessage() {
+    return __privateGet(this, _internals).validationMessage;
+  }
+  get willValidate() {
+    return __privateGet(this, _internals).willValidate;
+  }
+  checkValidity() {
+    return __privateGet(this, _internals).checkValidity();
+  }
+  reportValidity() {
+    return __privateGet(this, _internals).reportValidity();
+  }
+  connectedCallback() {
+    var _a;
+    super.connectedCallback();
+    (_a = __privateGet(this, _internals).form) == null ? void 0 : _a.addEventListener("reset", this._handleFormReset);
+  }
+  disconnectedCallback() {
+    var _a;
+    super.disconnectedCallback();
+    (_a = __privateGet(this, _internals).form) == null ? void 0 : _a.removeEventListener("reset", this._handleFormReset);
+  }
+  __handleValidityChange() {
+    __privateGet(this, _internals).setValidity(
+      {
+        badInput: false,
+        customError: this.invalid,
+        patternMismatch: false,
+        rangeOverflow: false,
+        rangeUnderflow: false,
+        stepMismatch: false,
+        tooLong: false,
+        tooShort: false,
+        typeMismatch: false,
+        valueMissing: false,
+        valid: !this.invalid
+      },
+      this.validationMessage || "Error message"
+    );
+  }
+  __handleValueChange() {
+    __privateGet(this, _internals).setFormValue(this.value);
+  }
+};
+_internals = new WeakMap();
+GdsFormControlElement.formAssociated = true;
+__decorateClass([
+  property({
+    type: Boolean,
+    reflect: true,
+    attribute: "aria-invalid",
+    converter: {
+      fromAttribute: Boolean,
+      toAttribute: (value) => value == null ? void 0 : value.toString()
+    }
+  })
+], GdsFormControlElement.prototype, "invalid", 2);
+__decorateClass([
+  property()
+], GdsFormControlElement.prototype, "value", 2);
+__decorateClass([
+  property({ reflect: true })
+], GdsFormControlElement.prototype, "name", 2);
+__decorateClass([
+  watch("invalid")
+], GdsFormControlElement.prototype, "__handleValidityChange", 1);
+__decorateClass([
+  watch("value")
+], GdsFormControlElement.prototype, "__handleValueChange", 1);
+
+export {
+  GdsFormControlElement
+};

package/chunks/chunk.YJHAKLGR.js

@@ -0,0 +1,54 @@
+import {
+  TransitionalStyles
+} from "./chunk.QONSFT2N.js";
+import {
+  GdsElement
+} from "./chunk.2LQSDOD4.js";
+import {
+  gdsCustomElement
+} from "./chunk.VOYMQ322.js";
+import {
+  __decorateClass
+} from "./chunk.5VURDMKE.js";
+
+// libs/core/src/primitives/menu/menu-heading.ts
+import { html } from "lit";
+
+// libs/core/src/primitives/menu/menu-heading.styles.ts
+import { css } from "lit";
+var style = css`
+  @layer base, reset, transitional-styles;
+  @layer base {
+    :host {
+      padding: 0.5 1rem;
+      cursor: pointer;
+    }
+
+    :host(:hover) {
+      background-color: grey;
+    }
+  }
+`;
+var menu_heading_styles_default = style;
+
+// libs/core/src/primitives/menu/menu-heading.ts
+var GdsMenuHeading = class extends GdsElement {
+  connectedCallback() {
+    super.connectedCallback();
+    this.setAttribute("inert", "true");
+    this.updateComplete.then(
+      () => TransitionalStyles.instance.apply(this, "gds-menu-heading")
+    );
+  }
+  render() {
+    return html`<slot></slot>`;
+  }
+};
+GdsMenuHeading.styles = menu_heading_styles_default;
+GdsMenuHeading = __decorateClass([
+  gdsCustomElement("gds-menu-heading")
+], GdsMenuHeading);
+
+export {
+  GdsMenuHeading
+};