@sbb-esta/lyne-elements-dev 4.7.0-dev.1773388991 → 4.7.0-dev.1773396165

package/core/base-elements/action-base-element.js

@@ -1,31 +1,39 @@
-import { SbbElement as e } from "./element.js";
 import { html as t } from "lit";
-//#region src/elements/core/base-elements/action-base-element.ts
-var n = class extends e {
-	get maybeDisabled() {
-		let e = this;
-		return e.disabled || e.formDisabled;
-	}
-	get maybeDisabledInteractive() {
-		return this.disabledInteractive;
-	}
-	constructor() {
-		super(), this.internals.states.add("action");
-	}
-	connectedCallback() {
-		super.connectedCallback();
-	}
-	setupBaseEventHandlers() {
-		this.addEventListener("click", (e) => {
-			this.maybeDisabled && !this.maybeDisabledInteractive && (e.preventDefault(), e.stopImmediatePropagation());
-		}, { capture: !0 });
-	}
-	renderTemplate() {
-		throw Error("Implementation needed!");
-	}
-	render() {
-		return t`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
-	}
+import { SbbElement as a } from "./element.js";
+class i extends a {
+  get maybeDisabled() {
+    const e = this;
+    return e.disabled || e.formDisabled;
+  }
+  get maybeDisabledInteractive() {
+    return this.disabledInteractive;
+  }
+  constructor() {
+    super(), this.internals.states.add("action");
+  }
+  connectedCallback() {
+    super.connectedCallback();
+  }
+  setupBaseEventHandlers() {
+    this.addEventListener(
+      "click",
+      (e) => {
+        this.maybeDisabled && !this.maybeDisabledInteractive && (e.preventDefault(), e.stopImmediatePropagation());
+      },
+      // capture is necessary here, as this event handler needs to be executed before any other
+      // in order to stop immediate propagation in the disabled case.
+      { capture: !0 }
+    );
+  }
+  /** Override this method to render the component template. */
+  renderTemplate() {
+    throw new Error("Implementation needed!");
+  }
+  /** Default render method for button-like components. */
+  render() {
+    return t`<span class="sbb-action-base ${this.localName}">${this.renderTemplate()}</span>`;
+  }
+}
+export {
+  i as SbbActionBaseElement
 };
-//#endregion
-export { n as SbbActionBaseElement };

package/core/base-elements/button-base-element.js

@@ -1,166 +1,146 @@
-import { SbbActionBaseElement as e } from "./action-base-element.js";
-import { __esDecorate as t, __runInitializers as n } from "tslib";
-import { isServer as r } from "lit";
-import { property as i } from "lit/decorators.js";
-import { forceType as a, hostAttributes as o } from "../decorators.js";
-import { isEventPrevented as s } from "../eventing.js";
-import { SbbFormAssociatedMixin as c } from "../mixins.js";
-//#region src/elements/core/base-elements/button-base-element.ts
-var l = (() => {
-	let i = [o({ tabindex: "0" })], a, s = [], l, u = c(e);
-	var d = class extends u {
-		static {
-			l = this;
-		}
-		static {
-			let e = typeof Symbol == "function" && Symbol.metadata ? Object.create(u[Symbol.metadata] ?? null) : void 0;
-			t(null, a = { value: l }, i, {
-				kind: "class",
-				name: l.name,
-				metadata: e
-			}, null, s), d = l = a.value, e && Object.defineProperty(l, Symbol.metadata, {
-				enumerable: !0,
-				configurable: !0,
-				writable: !0,
-				value: e
-			});
-		}
-		static {
-			this.role = "button";
-		}
-		constructor() {
-			if (super(), this._preventScrollOnSpaceKeydown = (e) => {
-				e.key === " " && (e.preventDefault(), this.internals.states.add("active"));
-			}, this._removeActiveMarker = () => {
-				this.internals.states.delete("active");
-			}, this._dispatchClickEventOnSpaceKeyup = (e) => {
-				e.key === " " && (this._removeActiveMarker(), this._dispatchClickEvent(e));
-			}, this._dispatchClickEvent = (e) => {
-				let { altKey: t, ctrlKey: n, metaKey: r, shiftKey: i } = e;
-				e.target.dispatchEvent(new PointerEvent("click", {
-					bubbles: !0,
-					cancelable: !0,
-					composed: !0,
-					pointerId: -1,
-					pointerType: "",
-					altKey: t,
-					ctrlKey: n,
-					metaKey: r,
-					shiftKey: i
-				}));
-			}, this.internals.states.add("button"), !r) {
-				this.setupBaseEventHandlers();
-				let e = { passive: !0 };
-				this.addEventListener("keydown", this._preventScrollOnSpaceKeydown), this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, e), this.addEventListener("blur", this._removeActiveMarker, e), this.addEventListener("keypress", (e) => {
-					(e.key === "Enter" || e.key === "\n") && this._dispatchClickEvent(e);
-				}, e);
-			}
-		}
-		attributeChangedCallback(e, t, n) {
-			(!["name", "value"].includes(e) || t !== n) && super.attributeChangedCallback(e, t, n);
-		}
-		static {
-			n(l, s);
-		}
-	};
-	return l;
-})(), u = (() => {
-	let e = l, r = [], o, c = [], u = [], d, f;
-	return class extends e {
-		static {
-			let n = typeof Symbol == "function" && Symbol.metadata ? Object.create(e[Symbol.metadata] ?? null) : void 0;
-			o = [a(), i()], d = [i()], f = [i()], t(this, null, o, {
-				kind: "accessor",
-				name: "value",
-				static: !1,
-				private: !1,
-				access: {
-					has: (e) => "value" in e,
-					get: (e) => e.value,
-					set: (e, t) => {
-						e.value = t;
-					}
-				},
-				metadata: n
-			}, c, u), t(this, null, d, {
-				kind: "setter",
-				name: "type",
-				static: !1,
-				private: !1,
-				access: {
-					has: (e) => "type" in e,
-					set: (e, t) => {
-						e.type = t;
-					}
-				},
-				metadata: n
-			}, null, r), t(this, null, f, {
-				kind: "setter",
-				name: "form",
-				static: !1,
-				private: !1,
-				access: {
-					has: (e) => "form" in e,
-					set: (e, t) => {
-						e.form = t;
-					}
-				},
-				metadata: n
-			}, null, r), n && Object.defineProperty(this, Symbol.metadata, {
-				enumerable: !0,
-				configurable: !0,
-				writable: !0,
-				value: n
-			});
-		}
-		#e;
-		get value() {
-			return this.#e;
-		}
-		set value(e) {
-			this.#e = e;
-		}
-		set type(e) {
-			this.setAttribute("type", `${e}`);
-		}
-		get type() {
-			return this.getAttribute("type") ?? "button";
-		}
-		set form(e) {
-			this._formId = e, this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
-		}
-		get form() {
-			return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
-		}
-		constructor() {
-			super(), this._elementsOnWhichEnterPressTriggersSubmit = (n(this, r), [
-				"input",
-				"sbb-date-input",
-				"sbb-time-input"
-			]), this.#e = n(this, c, ""), this._formId = (n(this, u), ""), this._handleButtonClick = async (e) => {
-				if (this.type === "button" || await s(e)) return;
-				let t = this.form;
-				if (t) this.type === "submit" ? this._requestSubmit(t) : this.type === "reset" && t.reset();
-				else return;
-			}, this._formKeyDown = (e) => {
-				let t = this.form;
-				this.type === "submit" && t && (e.key === "Enter" || e.key === "\n") && this._elementsOnWhichEnterPressTriggersSubmit.includes(e.target?.localName) && e.isTrusted && (e.stopImmediatePropagation(), e.preventDefault(), e.composedPath()[0].dispatchEvent(new KeyboardEvent(e.type, e)) && !this.matches(":disabled") && this._requestSubmit(t));
-			}, this.addEventListener("click", this._handleButtonClick);
-		}
-		connectedCallback() {
-			super.connectedCallback(), this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
-		}
-		disconnectedCallback() {
-			super.disconnectedCallback(), this.form?.removeEventListener("keydown", this._formKeyDown, { capture: !0 });
-		}
-		_requestSubmit(e) {
-			let t = document.createElement("button");
-			t.inert = !0, t.hidden = !0, t.name = this.name, t.value = this.value ?? "", e.append(t), e.requestSubmit(t), t.remove();
-		}
-		formResetCallback() {}
-		formStateRestoreCallback(e, t) {}
-		updateFormValue() {}
-	};
+var _ = (i) => {
+  throw TypeError(i);
+};
+var v = (i, a, n) => a.has(i) || _("Cannot " + n);
+var k = (i, a, n) => (v(i, a, "read from private field"), n ? n.call(i) : a.get(i)), E = (i, a, n) => a.has(i) ? _("Cannot add the same private member more than once") : a instanceof WeakSet ? a.add(i) : a.set(i, n), p = (i, a, n, l) => (v(i, a, "write to private field"), l ? l.call(i, n) : a.set(i, n), n);
+import { __esDecorate as d, __runInitializers as h } from "tslib";
+import { isServer as S } from "lit";
+import { property as f } from "lit/decorators.js";
+import { hostAttributes as g, forceType as C } from "../decorators.js";
+import { isEventPrevented as w } from "../eventing.js";
+import { SbbFormAssociatedMixin as K } from "../mixins.js";
+import { SbbActionBaseElement as O } from "./action-base-element.js";
+let I = (() => {
+  var o;
+  let i = [g({
+    tabindex: "0"
+  })], a, n = [], l, u = K(O);
+  return o = class extends u {
+    constructor() {
+      if (super(), this._preventScrollOnSpaceKeydown = (s) => {
+        s.key === " " && (s.preventDefault(), this.internals.states.add("active"));
+      }, this._removeActiveMarker = () => {
+        this.internals.states.delete("active");
+      }, this._dispatchClickEventOnSpaceKeyup = (s) => {
+        s.key === " " && (this._removeActiveMarker(), this._dispatchClickEvent(s));
+      }, this._dispatchClickEvent = (s) => {
+        const { altKey: r, ctrlKey: m, metaKey: y, shiftKey: t } = s;
+        s.target.dispatchEvent(new PointerEvent("click", {
+          bubbles: !0,
+          cancelable: !0,
+          composed: !0,
+          pointerId: -1,
+          pointerType: "",
+          altKey: r,
+          ctrlKey: m,
+          metaKey: y,
+          shiftKey: t
+        }));
+      }, this.internals.states.add("button"), !S) {
+        this.setupBaseEventHandlers();
+        const s = { passive: !0 };
+        this.addEventListener("keydown", this._preventScrollOnSpaceKeydown), this.addEventListener("keyup", this._dispatchClickEventOnSpaceKeyup, s), this.addEventListener("blur", this._removeActiveMarker, s), this.addEventListener("keypress", (r) => {
+          (r.key === "Enter" || r.key === `
+`) && this._dispatchClickEvent(r);
+        }, s);
+      }
+    }
+    attributeChangedCallback(s, r, m) {
+      (!["name", "value"].includes(s) || r !== m) && super.attributeChangedCallback(s, r, m);
+    }
+  }, l = o, (() => {
+    const s = typeof Symbol == "function" && Symbol.metadata ? Object.create(u[Symbol.metadata] ?? null) : void 0;
+    d(null, a = { value: l }, i, { kind: "class", name: l.name, metadata: s }, null, n), l = a.value, s && Object.defineProperty(l, Symbol.metadata, { enumerable: !0, configurable: !0, writable: !0, value: s });
+  })(), o.role = "button", h(l, n), l;
+})(), q = (() => {
+  var s, r;
+  let i = I, a = [], n, l = [], u = [], o, b;
+  return r = class extends i {
+    constructor() {
+      super();
+      E(this, s);
+      this._elementsOnWhichEnterPressTriggersSubmit = (h(this, a), [
+        "input",
+        "sbb-date-input",
+        "sbb-time-input"
+      ]), p(this, s, h(this, l, "")), this._formId = (h(this, u), ""), this._handleButtonClick = async (t) => {
+        if (this.type === "button" || await w(t))
+          return;
+        const e = this.form;
+        if (e)
+          this.type === "submit" ? this._requestSubmit(e) : this.type === "reset" && e.reset();
+        else return;
+      }, this._formKeyDown = (t) => {
+        const e = this.form;
+        this.type === "submit" && e && (t.key === "Enter" || t.key === `
+`) && this._elementsOnWhichEnterPressTriggersSubmit.includes(t.target?.localName) && t.isTrusted && (t.stopImmediatePropagation(), t.preventDefault(), t.composedPath()[0].dispatchEvent(new KeyboardEvent(t.type, t)) && !this.matches(":disabled") && this._requestSubmit(e));
+      }, this.addEventListener("click", this._handleButtonClick);
+    }
+    /** Value of the form element. */
+    get value() {
+      return k(this, s);
+    }
+    set value(t) {
+      p(this, s, t);
+    }
+    /**
+     * The type attribute to use for the button.
+     * @default 'button'
+     */
+    set type(t) {
+      this.setAttribute("type", `${t}`);
+    }
+    get type() {
+      return this.getAttribute("type") ?? "button";
+    }
+    /** The `<form>` element to associate the button with. */
+    set form(t) {
+      this._formId = t, this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    get form() {
+      return this._formId ? this.getRootNode?.()?.getElementById?.(this._formId) ?? null : this.internals.form;
+    }
+    connectedCallback() {
+      super.connectedCallback(), this.form?.addEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback(), this.form?.removeEventListener("keydown", this._formKeyDown, { capture: !0 });
+    }
+    _requestSubmit(t) {
+      const e = document.createElement("button");
+      e.inert = !0, e.hidden = !0, e.name = this.name, e.value = this.value ?? "", t.append(e), t.requestSubmit(e), e.remove();
+    }
+    /**
+     * Intentionally empty, as buttons are not targeted by form reset
+     * @internal
+     */
+    formResetCallback() {
+    }
+    /**
+     * Intentionally empty, as buttons are not targeted by form restore
+     * @internal
+     */
+    formStateRestoreCallback(t, e) {
+    }
+    /**
+     * Intentionally empty, as button does not write its data in form.
+     * The data is only applied on submit button click as submitter of requestSubmit();
+     * @internal
+     */
+    updateFormValue() {
+    }
+  }, s = new WeakMap(), (() => {
+    const t = typeof Symbol == "function" && Symbol.metadata ? Object.create(i[Symbol.metadata] ?? null) : void 0;
+    n = [C(), f()], o = [f()], b = [f()], d(r, null, n, { kind: "accessor", name: "value", static: !1, private: !1, access: { has: (e) => "value" in e, get: (e) => e.value, set: (e, c) => {
+      e.value = c;
+    } }, metadata: t }, l, u), d(r, null, o, { kind: "setter", name: "type", static: !1, private: !1, access: { has: (e) => "type" in e, set: (e, c) => {
+      e.type = c;
+    } }, metadata: t }, null, a), d(r, null, b, { kind: "setter", name: "form", static: !1, private: !1, access: { has: (e) => "form" in e, set: (e, c) => {
+      e.form = c;
+    } }, metadata: t }, null, a), t && Object.defineProperty(r, Symbol.metadata, { enumerable: !0, configurable: !0, writable: !0, value: t });
+  })(), r;
 })();
-//#endregion
-export { u as SbbButtonBaseElement, l as SbbButtonLikeBaseElement };
+export {
+  q as SbbButtonBaseElement,
+  I as SbbButtonLikeBaseElement
+};

package/core/base-elements/element.js

@@ -1,29 +1,64 @@
-import { LitElement as e } from "lit";
-import { SbbElementInternalsMixin as t } from "../mixins/element-internals-mixin.js";
-import { SbbHydrationMixin as n } from "../mixins/hydration-mixin.js";
-//#region src/elements/core/base-elements/element.ts
-var r = class extends n(t(e)) {
-	static {
-		this._$sbbElement$ = !0;
-	}
-	static define(e = customElements) {
-		e.get(this.elementName) || e.define(this.elementName, this);
-	}
-	addController(e) {
-		super.addController(e), (this._controllers ??= /* @__PURE__ */ new Set()).add(e);
-	}
-	removeController(e) {
-		super.removeController(e), this._controllers?.delete(e);
-	}
-	requestUpdate(e, t, n, r, i) {
-		if (super.requestUpdate(e, t, n, r, i), e) {
-			let a = {
-				oldValue: t,
-				value: r ? i : this[e]
-			};
-			this._controllers?.forEach((t) => t.hostPropertyUpdate?.(e, a, n));
-		}
-	}
+import { LitElement as a } from "lit";
+import { SbbElementInternalsMixin as m } from "../mixins/element-internals-mixin.js";
+import { SbbHydrationMixin as h } from "../mixins/hydration-mixin.js";
+const r = class r extends h(m(a)) {
+  /**
+   * Register the custom element to the specified CustomElementRegistry.
+   * If none is provided, defaults to the global `customElements` registry.
+   * @param customElementRegistry Optional CustomElementRegistry to register this element to.
+   *   Defaults to the global `customElements` instance.
+   */
+  static define(e = customElements) {
+    e.get(this.elementName) || e.define(this.elementName, this);
+  }
+  /**
+   * Registers a `ReactiveController` to participate in the element's reactive
+   * update cycle. The element automatically calls into any registered
+   * controllers during its lifecycle callbacks.
+   *
+   * If the element is connected when `addController()` is called, the
+   * controller's `hostConnected()` callback will be immediately called.
+   */
+  addController(e) {
+    super.addController(e), (this._controllers ??= /* @__PURE__ */ new Set()).add(e);
+  }
+  /**
+   * Removes a `ReactiveController` from the element.
+   */
+  removeController(e) {
+    super.removeController(e), this._controllers?.delete(e);
+  }
+  /**
+   * Requests an update which is processed asynchronously. This should be called
+   * when an element should update based on some state not triggered by setting
+   * a reactive property. In this case, pass no arguments. It should also be
+   * called when manually implementing a property setter. In this case, pass the
+   * property `name` and `oldValue` to ensure that any configured property
+   * options are honored.
+   *
+   * @param name name of requesting property
+   * @param oldValue old value of requesting property
+   * @param options property options to use instead of the previously
+   *     configured options
+   * @param useNewValue if true, the newValue argument is used instead of
+   *     reading the property value. This is important to use if the reactive
+   *     property is a standard private accessor, as opposed to a plain
+   *     property, since private members can't be dynamically read by name.
+   * @param newValue the new value of the property. This is only used if
+   *     `useNewValue` is true.
+   */
+  requestUpdate(e, t, s, o, i) {
+    if (super.requestUpdate(e, t, s, o, i), e) {
+      const n = {
+        oldValue: t,
+        value: o ? i : this[e]
+      };
+      this._controllers?.forEach((d) => d.hostPropertyUpdate?.(e, n, s));
+    }
+  }
+};
+r._$sbbElement$ = !0;
+let l = r;
+export {
+  l as SbbElement
 };
-//#endregion
-export { r as SbbElement };