@sebgroup/green-core 1.15.1 → 1.17.0

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.XMPBXAGB.js

@@ -0,0 +1,80 @@
+// libs/core/src/components/grid/grid.style.css.ts
+import { css } from "lit";
+var style = css`
+  @layer grid, grid.desktop, grid.tablet, grid.mobile, grid.span, grid.space, grid.align, grid.debug;
+
+  @layer grid {
+    :host {
+      --_c: var(--gds-sys-grid-columns-12);
+      --_grid-col: repeat(var(--_c), 1fr);
+      --_grid-col-start: 1;
+      --_grid-col-end: -1;
+      --_gap-column: 0;
+      --_gap-row: 0;
+      display: grid;
+      width: 100%;
+      grid-template-columns: var(--_grid-col);
+      grid-column-gap: var(--_gap-column);
+      grid-row-gap: var(--_gap-row);
+      padding: var(--_grid-padding);
+      text-wrap: balance;
+    }
+
+    :host([auto-columns]) {
+      --_col-count: var(--_c, 0);
+      --_gap-count: calc(var(--_col-count) - 1);
+      --_total-gap-width: calc(var(--_gap-count) * var(--_gap-column, 0px));
+      --_col-width-max: calc(
+        (100% - var(--_total-gap-width)) / var(--_col-count)
+      );
+      grid-template-columns: repeat(
+        auto-fill,
+        minmax(max(var(--_col-width), var(--_col-width-max)), 1fr)
+      );
+    }
+  }
+
+  /* Responsive */
+
+  :host([columns]) {
+    --_c: var(--_columns-desktop);
+  }
+
+  :host {
+    --_gap-column: var(--_gap-desktop);
+    --_gap-row: var(--_row-gap-desktop);
+    --_grid-padding: var(--_padding-desktop);
+    --_col-width: var(--_col-width-desktop);
+  }
+
+  @media only screen and (max-width: 768px) {
+    :host([columns]) {
+      --_c: var(--_columns-tablet);
+    }
+
+    :host {
+      --_gap-column: var(--_gap-tablet);
+      --_gap-row: var(--_row-gap-tablet);
+      --_grid-padding: var(--_padding-tablet);
+      --_col-width: var(--_col-width-tablet);
+    }
+  }
+
+  @media only screen and (max-width: 425px) {
+    :host([columns]) {
+      --_c: var(--_columns-mobile);
+    }
+
+    :host {
+      --_gap-column: var(--_gap-mobile);
+      --_gap-row: var(--_row-gap-mobile);
+      --_grid-padding: var(--_padding-mobile);
+      --_col-width: var(--_col-width-mobile);
+    }
+  }
+`;
+var grid_style_css_default = style;
+
+export {
+  grid_style_css_default
+};

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
+};