@sbb-esta/lyne-elements-dev 0.0.0 → 4.5.1-dev.1771849268

package/development/clock/clock.component.js

@@ -0,0 +1,369 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+import { __runInitializers, __esDecorate } from "tslib";
+import { css, LitElement, isServer, html } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import { ref } from "lit/directives/ref.js";
+import { SbbElementInternalsMixin } from "../core/mixins.js";
+import { boxSizingStyles } from "../core/styles.js";
+const clockFaceSVG = '<svg focusable="false" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 105 105"><g class="face"><circle fill="var(--sbb-clock-background-color)" cx="52.5" cy="52.5" r="52.5"/><path d="M50.75 4h3.5v12h-3.5zM50.75 89h3.5v12h-3.5zM75.233 9.623l3.03 1.75-6 10.392-3.03-1.75zM32.734 83.233l3.03 1.75-6 10.392-3.03-1.75zM93.628 26.732l1.75 3.031-10.392 6-1.75-3.03zM20.017 69.234l1.75 3.031-10.392 6-1.75-3.03zM101 50.75v3.5H89v-3.5zM16 50.75v3.5H4v-3.5zM95.379 75.232l-1.75 3.031-10.392-6 1.75-3.03zM21.766 32.734l-1.75 3.031-10.392-6 1.75-3.03zM78.267 93.63l-3.03 1.75-6-10.393 3.03-1.75zM35.766 20.015l-3.03 1.75-6-10.392 3.03-1.75z"/><g><path d="M56.873 4.19l1.392.147-.366 3.48-1.392-.145zM47.101 97.177l1.393.146-.366 3.481-1.392-.146zM61.896 4.914l1.37.29-.728 3.424-1.37-.29zM42.458 96.366l1.37.29-.728 3.424-1.37-.291zM66.825 6.157l1.332.432-1.082 3.33-1.331-.434zM37.931 95.085l1.332.432-1.082 3.33-1.331-.433zM71.584 7.906l1.28.569-1.424 3.197-1.28-.57zM33.56 93.32l1.278.569-1.423 3.197-1.28-.57zM80.44 12.852l1.133.823-2.058 2.831-1.132-.823zM25.481 88.494l1.133.822-2.057 2.832-1.133-.823zM84.43 15.986l1.04.937-2.342 2.6-1.04-.936zM21.87 85.469l1.04.936-2.341 2.601-1.04-.937zM88.072 19.522l.937 1.04-2.6 2.343-.937-1.04zM18.593 82.088l.937 1.04-2.601 2.342-.937-1.04zM91.328 23.425l.823 1.133-2.832 2.057-.823-1.132zM15.684 78.385l.823 1.132-2.832 2.058-.822-1.133zM96.52 32.128l.57 1.279-3.198 1.423-.57-1.278zM11.109 70.161l.569 1.279-3.197 1.423-.57-1.279zM98.407 36.85l.433 1.332-3.33 1.081-.432-1.331zM9.483 65.74l.432 1.33-3.329 1.082-.432-1.331zM99.795 41.726l.291 1.37-3.423.727-.29-1.37zM8.34 61.17l.292 1.37-3.424.728-.29-1.37zM100.66 46.73l.146 1.393-3.48.366-.147-1.392zM7.674 56.506l.146 1.392-3.48.366-.147-1.392zM100.811 56.873l-.146 1.392-3.48-.365.145-1.393zM7.821 47.101l-.146 1.392-3.48-.365.145-1.393zM100.09 61.895l-.291 1.369-3.424-.728.291-1.369zM8.631 42.46l-.291 1.37-3.423-.728.29-1.37zM98.84 66.827l-.432 1.331-3.329-1.081.433-1.332zM9.918 37.93l-.433 1.331-3.329-1.082.433-1.331zM97.098 71.585l-.569 1.28-3.197-1.424.57-1.28zM11.677 33.558l-.57 1.28-3.197-1.424.57-1.279zM92.149 80.439l-.823 1.133-2.832-2.058.823-1.132zM16.506 25.482l-.823 1.133-2.831-2.057.823-1.133zM89.017 84.431l-.937 1.04-2.6-2.341.936-1.04zM19.528 21.869l-.936 1.04-2.601-2.342.936-1.04zM85.48 88.076l-1.041.936-2.342-2.6 1.04-.937zM22.91 18.59l-1.04.937-2.341-2.601 1.04-.937zM81.574 91.328l-1.133.823-2.057-2.831 1.132-.823zM26.617 15.684l-1.133.823-2.057-2.832 1.132-.823zM72.873 96.524l-1.279.57-1.423-3.198 1.278-.57zM34.838 11.105l-1.279.57-1.423-3.198 1.279-.57zM68.151 98.405l-1.331.432-1.082-3.329 1.332-.432zM39.259 9.485l-1.332.433-1.081-3.33 1.331-.432zM63.272 99.799l-1.369.29-.728-3.422 1.37-.291zM43.83 8.337l-1.369.291-.727-3.423 1.37-.291zM58.27 100.662l-1.393.146-.366-3.48 1.393-.147zM48.494 7.672l-1.392.147-.366-3.481 1.392-.147z"/></g></g></svg>\n';
+const clockHandleHoursSVG = '<svg focusable="false" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 105 105"><path id="mod_clock_svg_hours" d="M55.7 64.5h-6.4l.6-44h5.2z"/></svg>\n';
+const clockHandleMinutesSVG = '<svg focusable="false" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 105 105"><path d="M55.1,64.5h-5.2l0.8-58h3.6L55.1,64.5z"/></svg>\n';
+const clockHandleSecondsSVG = '<svg focusable="false" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 105 105"><path d="M57.8,21.3c0-2.9-2.4-5.2-5.2-5.2s-5.3,2.3-5.3,5.2c0,2.7,2,4.8,4.5,5.2V69h1.5V26.5C55.8,26.2,57.8,24,57.8,21.3z"/></svg>\n';
+const style = css`:host {
+  display: block;
+  position: relative;
+  aspect-ratio: 1/1;
+  overflow: hidden;
+  contain: content;
+}
+
+.sbb-clock__face,
+.sbb-clock__hand-hours,
+.sbb-clock__hand-minutes,
+.sbb-clock__hand-seconds {
+  position: absolute;
+  inset: 0;
+  transform-origin: center center;
+  transform: rotateZ(0deg);
+  transform-style: preserve-3d;
+  backface-visibility: hidden;
+}
+
+.sbb-clock__hand-hours,
+.sbb-clock__hand-minutes,
+.sbb-clock__face {
+  fill: var(--sbb-clock-face-color);
+}
+
+.sbb-clock__hand-minutes {
+  transition: transform var(--sbb-disable-animation-duration, 0.2s) cubic-bezier(0.4, 2.08, 0.55, 0.44);
+}
+@supports not (aspect-ratio: 1/1) {
+  .sbb-clock__hand-minutes {
+    transform-origin: 50% 49.625%;
+  }
+}
+
+.sbb-clock__hand-hours {
+  animation-name: rotate;
+  animation-duration: 43200s;
+  animation-iteration-count: infinite;
+  animation-timing-function: linear;
+  animation-play-state: var(--sbb-clock-animation-play-state, "paused");
+}
+
+.sbb-clock__hand-hours--initial-hour {
+  animation-name: hand-hours-animation-initial-hour;
+  animation-duration: var(--sbb-clock-hours-animation-duration, 0s);
+  animation-play-state: var(--sbb-clock-animation-play-state, "paused");
+  animation-iteration-count: 1;
+}
+
+.sbb-clock__hand-minutes--no-transition {
+  transition: none;
+}
+
+.sbb-clock__hand-seconds {
+  animation-name: hand-seconds-animation;
+  animation-duration: 60s;
+  animation-timing-function: linear;
+  animation-play-state: var(--sbb-clock-animation-play-state, "paused");
+  animation-iteration-count: infinite;
+  fill: var(--sbb-clock-seconds-hand-color);
+}
+
+.sbb-clock__hand-seconds--initial-minute {
+  animation-name: hand-seconds-animation-initial-minute;
+  animation-duration: var(--sbb-clock-seconds-animation-duration, 0s);
+  animation-play-state: var(--sbb-clock-animation-play-state, "paused");
+  animation-iteration-count: 1;
+}
+
+:host(:not(:is(:state(initialized),[state--initialized]))) :is(.sbb-clock__hand-hours, .sbb-clock__hand-minutes, .sbb-clock__hand-seconds) {
+  display: none;
+}
+
+@keyframes rotate {
+  100% {
+    transform: rotateZ(360deg);
+  }
+}
+@keyframes hand-hours-animation-initial-hour {
+  0% {
+    transform: rotateZ(var(--sbb-clock-hours-animation-start-angle, 0deg));
+  }
+  100% {
+    transform: rotateZ(360deg);
+  }
+}
+@keyframes hand-seconds-animation {
+  0% {
+    transform: rotateZ(0deg);
+  }
+  97.5%, 100% {
+    transform: rotateZ(360deg);
+  }
+}
+@keyframes hand-seconds-animation-initial-minute {
+  0% {
+    transform: rotateZ(var(--sbb-clock-seconds-animation-start-angle, 0deg));
+  }
+  97.5%, 100% {
+    transform: rotateZ(360deg);
+  }
+}`;
+const TOTAL_HOURS_ON_CLOCK_FACE = 12;
+const TOTAL_MINUTES_ON_CLOCK_FACE = 60;
+const TOTAL_SECONDS_ON_CLOCK_FACE = 60;
+const INITIAL_TIMEOUT_DURATION = 50;
+const FULL_ANGLE = 360;
+const HOURS_ANGLE = 30;
+const MINUTES_ANGLE = 6;
+const SBB_SECONDS_ANGLE = 360 / 58.5;
+const SECONDS_IN_A_MINUTE = 60;
+const SECONDS_IN_AN_HOUR = 3600;
+const RESET_INTERVAL = SECONDS_IN_AN_HOUR / 2;
+const ADD_EVENT_LISTENER_OPTIONS = {
+  once: true,
+  passive: true
+};
+let SbbClockElement = (() => {
+  var _now_accessor_storage, _a;
+  let _classDecorators = [customElement("sbb-clock")];
+  let _classDescriptor;
+  let _classExtraInitializers = [];
+  let _classThis;
+  let _classSuper = SbbElementInternalsMixin(LitElement);
+  let _now_decorators;
+  let _now_initializers = [];
+  let _now_extraInitializers = [];
+  _a = class extends _classSuper {
+    constructor() {
+      super(...arguments);
+      __privateAdd(this, _now_accessor_storage);
+      __privateSet(this, _now_accessor_storage, __runInitializers(this, _now_initializers, null));
+      this._state = (__runInitializers(this, _now_extraInitializers), "paused");
+      this._moveHoursHandFn = () => this._moveHoursHand();
+      this._moveMinutesHandFn = () => this._moveMinutesHand();
+      this._handlePageVisibilityChange = async () => {
+        if (this.now) {
+          return;
+        }
+        if (document.visibilityState === "hidden") {
+          await this._stopClock();
+        } else {
+          await this._startClock();
+        }
+      };
+    }
+    /**
+     * Define a specific time which the clock should show statically.
+     * @param value HH:MM:ss
+     */
+    get now() {
+      return __privateGet(this, _now_accessor_storage);
+    }
+    set now(value) {
+      __privateSet(this, _now_accessor_storage, value);
+    }
+    connectedCallback() {
+      super.connectedCallback();
+      this._resetIntervalId = setInterval(() => this._resetClock(), RESET_INTERVAL * 1e3);
+    }
+    willUpdate(changedProperties) {
+      super.willUpdate(changedProperties);
+      if (!isServer && changedProperties.has("now")) {
+        this._startOrConfigureClock();
+      }
+    }
+    firstUpdated(changedProperties) {
+      super.firstUpdated(changedProperties);
+      if (!isServer) {
+        document.addEventListener("visibilitychange", this._handlePageVisibilityChange, false);
+        this._startOrConfigureClock();
+      }
+    }
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this._removeEventListeners();
+      clearInterval(this._resetIntervalId);
+    }
+    async _startOrConfigureClock() {
+      if (this.now) {
+        await this._stopClock();
+        this._resetSecondsHandAnimation();
+        this._setHandsStartingPosition();
+      } else {
+        await this._startClock();
+      }
+    }
+    /** Starts the clock by defining the hands starting position then starting the animations. */
+    async _startClock() {
+      this._clockHandHours?.addEventListener("animationend", this._moveHoursHandFn, ADD_EVENT_LISTENER_OPTIONS);
+      this._clockHandSeconds?.addEventListener("animationend", this._moveMinutesHandFn, ADD_EVENT_LISTENER_OPTIONS);
+      await new Promise((resolve) => setTimeout(() => {
+        this._setHandsStartingPosition();
+        this.style?.setProperty("--sbb-clock-animation-play-state", "running");
+        this._state = "running";
+        resolve();
+      }, INITIAL_TIMEOUT_DURATION));
+    }
+    /** Stops the clock by removing all the animations. */
+    async _stopClock() {
+      clearInterval(this._handMovement);
+      this._removeSecondsAnimationStyles();
+      this._removeHoursAnimationStyles();
+      this._clockHandHours?.removeEventListener("animationend", this._moveHoursHandFn);
+      this._clockHandSeconds?.removeEventListener("animationend", this._moveMinutesHandFn);
+      this._clockHandMinutes?.classList.add("sbb-clock__hand-minutes--no-transition");
+      this.style?.setProperty("--sbb-clock-animation-play-state", "paused");
+      this._state = "paused";
+    }
+    /**
+     * As a fallback measure to prevent de-sync, reset the clock to the system time.
+     */
+    async _resetClock() {
+      if (this._state !== "running") {
+        return;
+      }
+      await this._stopClock();
+      await this._startClock();
+    }
+    /** Set the starting position for the three hands on the clock face. */
+    _setHandsStartingPosition() {
+      this._assignCurrentTime();
+      const remainingSeconds = TOTAL_SECONDS_ON_CLOCK_FACE - this._seconds;
+      const remainingMinutes = TOTAL_MINUTES_ON_CLOCK_FACE - this._minutes;
+      const remainingHours = TOTAL_HOURS_ON_CLOCK_FACE - this._hours;
+      let hoursAnimationDuration = 0;
+      let hasRemainingMinutesOrSeconds = 0;
+      if (remainingSeconds > 0) {
+        hoursAnimationDuration += remainingSeconds;
+        hasRemainingMinutesOrSeconds = 1;
+      }
+      if (remainingMinutes > 0) {
+        hoursAnimationDuration += (remainingMinutes - hasRemainingMinutesOrSeconds) * SECONDS_IN_A_MINUTE;
+        hasRemainingMinutesOrSeconds = 1;
+      }
+      if (remainingHours > 0) {
+        hoursAnimationDuration += (remainingHours - hasRemainingMinutesOrSeconds) * SECONDS_IN_AN_HOUR;
+      }
+      this.style?.setProperty("--sbb-clock-hours-animation-start-angle", `${Math.ceil(this._hours * HOURS_ANGLE + this._minutes / 2)}deg`);
+      this.style?.setProperty("--sbb-clock-hours-animation-duration", `${hoursAnimationDuration}s`);
+      this.style?.setProperty("--sbb-clock-seconds-animation-start-angle", `${Math.ceil(this._seconds * SBB_SECONDS_ANGLE)}deg`);
+      this.style?.setProperty("--sbb-clock-seconds-animation-duration", `${remainingSeconds}s`);
+      this._setMinutesHand();
+      this._clockHandSeconds?.classList.add("sbb-clock__hand-seconds--initial-minute");
+      this._clockHandHours?.classList.add("sbb-clock__hand-hours--initial-hour");
+      this.internals.states.add("initialized");
+    }
+    /** Given the current date, calculates the hh/mm/ss values and the hh/mm/ss left to the next midnight. */
+    _assignCurrentTime() {
+      const date = this.now ? null : /* @__PURE__ */ new Date();
+      const [hours, minutes, seconds] = date ? [date.getHours(), date.getMinutes(), date.getSeconds()] : this.now.split(":").map((p) => +p);
+      this._hours = hours % 12;
+      this._minutes = minutes;
+      this._seconds = seconds;
+    }
+    /** Set the starting position for the minutes hand. */
+    _setMinutesHand() {
+      this._clockHandMinutes?.style.setProperty("transform", `rotateZ(${Math.ceil(this._minutes * MINUTES_ANGLE)}deg)`);
+    }
+    /** Move the hours hand to the next value. */
+    _moveHoursHand() {
+      this._removeHoursAnimationStyles();
+      let hoursAngle = Math.ceil(this._hours * HOURS_ANGLE + this._minutes / 2);
+      if (hoursAngle >= FULL_ANGLE) {
+        hoursAngle -= FULL_ANGLE;
+      }
+      this._clockHandHours?.style.setProperty("transform", `rotateZ(${hoursAngle}deg)`);
+    }
+    /** Move the minutes hand to the next value. */
+    _moveMinutesHand() {
+      this._clockHandSeconds?.removeEventListener("animationend", this._moveMinutesHandFn);
+      this._removeSecondsAnimationStyles();
+      this._addMinutesAndSetHands();
+      this._handMovement = setInterval(() => this._addMinutesAndSetHands(), TOTAL_SECONDS_ON_CLOCK_FACE * 1e3);
+    }
+    _addMinutesAndSetHands() {
+      this._minutes++;
+      this._setMinutesHand();
+    }
+    /**
+     * Removing animation by overriding with empty string,
+     * then triggering a reflow and re add original animation by removing override.
+     * @private
+     */
+    _resetSecondsHandAnimation() {
+      if (!this._clockHandSeconds) {
+        return;
+      }
+      this._clockHandSeconds.style.animation = "";
+      this._clockHandSeconds.offsetHeight;
+      this._clockHandSeconds.style.removeProperty("animation");
+    }
+    _removeEventListeners() {
+      document?.removeEventListener("visibilitychange", this._handlePageVisibilityChange);
+      this._clockHandHours?.removeEventListener("animationend", this._moveHoursHandFn);
+      this._clockHandSeconds?.removeEventListener("animationend", this._moveMinutesHandFn);
+      clearInterval(this._handMovement);
+    }
+    _removeHoursAnimationStyles() {
+      this._clockHandHours?.classList.remove("sbb-clock__hand-hours--initial-hour");
+      this.style.removeProperty("--sbb-clock-hours-animation-start-angle");
+      this.style.removeProperty("--sbb-clock-hours-animation-duration");
+    }
+    _removeSecondsAnimationStyles() {
+      this._clockHandSeconds?.classList.remove("sbb-clock__hand-seconds--initial-minute");
+      this._clockHandMinutes?.classList.remove("sbb-clock__hand-minutes--no-transition");
+      this.style.removeProperty("--sbb-clock-seconds-animation-start-angle");
+      this.style.removeProperty("--sbb-clock-seconds-animation-duration");
+    }
+    render() {
+      return html`
+      <span class="sbb-clock__face" .innerHTML=${clockFaceSVG}></span>
+      <span
+        class="sbb-clock__hand-hours"
+        .innerHTML=${clockHandleHoursSVG}
+        ${ref((e) => {
+        this._clockHandHours = e;
+      })}
+      ></span>
+      <span
+        class="sbb-clock__hand-minutes sbb-clock__hand-minutes--no-transition"
+        .innerHTML=${clockHandleMinutesSVG}
+        ${ref((el) => {
+        this._clockHandMinutes = el;
+      })}
+      ></span>
+      <span
+        class="sbb-clock__hand-seconds"
+        .innerHTML=${clockHandleSecondsSVG}
+        ${ref((el) => {
+        this._clockHandSeconds = el;
+      })}
+      ></span>
+    `;
+    }
+  }, _now_accessor_storage = new WeakMap(), _classThis = _a, (() => {
+    const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+    _now_decorators = [property()];
+    __esDecorate(_a, null, _now_decorators, { kind: "accessor", name: "now", static: false, private: false, access: { has: (obj) => "now" in obj, get: (obj) => obj.now, set: (obj, value) => {
+      obj.now = value;
+    } }, metadata: _metadata }, _now_initializers, _now_extraInitializers);
+    __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+    _classThis = _classDescriptor.value;
+    if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+  })(), _a.styles = [boxSizingStyles, style], __runInitializers(_classThis, _classExtraInitializers), _a;
+  return _classThis;
+})();
+export {
+  SbbClockElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"clock.component.js","sources":["../../../../src/elements/clock/assets/sbb_clock_face.svg?raw","../../../../src/elements/clock/assets/sbb_clock_hours.svg?raw","../../../../src/elements/clock/assets/sbb_clock_minutes.svg?raw","../../../../src/elements/clock/assets/sbb_clock_seconds.svg?raw","../../../../src/elements/clock/clock.component.ts"],"sourcesContent":["export default \"<svg focusable=\\\"false\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\" viewBox=\\\"0 0 105 105\\\"><g class=\\\"face\\\"><circle fill=\\\"var(--sbb-clock-background-color)\\\" cx=\\\"52.5\\\" cy=\\\"52.5\\\" r=\\\"52.5\\\"/><path d=\\\"M50.75 4h3.5v12h-3.5zM50.75 89h3.5v12h-3.5zM75.233 9.623l3.03 1.75-6 10.392-3.03-1.75zM32.734 83.233l3.03 1.75-6 10.392-3.03-1.75zM93.628 26.732l1.75 3.031-10.392 6-1.75-3.03zM20.017 69.234l1.75 3.031-10.392 6-1.75-3.03zM101 50.75v3.5H89v-3.5zM16 50.75v3.5H4v-3.5zM95.379 75.232l-1.75 3.031-10.392-6 1.75-3.03zM21.766 32.734l-1.75 3.031-10.392-6 1.75-3.03zM78.267 93.63l-3.03 1.75-6-10.393 3.03-1.75zM35.766 20.015l-3.03 1.75-6-10.392 3.03-1.75z\\\"/><g><path d=\\\"M56.873 4.19l1.392.147-.366 3.48-1.392-.145zM47.101 97.177l1.393.146-.366 3.481-1.392-.146zM61.896 4.914l1.37.29-.728 3.424-1.37-.29zM42.458 96.366l1.37.29-.728 3.424-1.37-.291zM66.825 6.157l1.332.432-1.082 3.33-1.331-.434zM37.931 95.085l1.332.432-1.082 3.33-1.331-.433zM71.584 7.906l1.28.569-1.424 3.197-1.28-.57zM33.56 93.32l1.278.569-1.423 3.197-1.28-.57zM80.44 12.852l1.133.823-2.058 2.831-1.132-.823zM25.481 88.494l1.133.822-2.057 2.832-1.133-.823zM84.43 15.986l1.04.937-2.342 2.6-1.04-.936zM21.87 85.469l1.04.936-2.341 2.601-1.04-.937zM88.072 19.522l.937 1.04-2.6 2.343-.937-1.04zM18.593 82.088l.937 1.04-2.601 2.342-.937-1.04zM91.328 23.425l.823 1.133-2.832 2.057-.823-1.132zM15.684 78.385l.823 1.132-2.832 2.058-.822-1.133zM96.52 32.128l.57 1.279-3.198 1.423-.57-1.278zM11.109 70.161l.569 1.279-3.197 1.423-.57-1.279zM98.407 36.85l.433 1.332-3.33 1.081-.432-1.331zM9.483 65.74l.432 1.33-3.329 1.082-.432-1.331zM99.795 41.726l.291 1.37-3.423.727-.29-1.37zM8.34 61.17l.292 1.37-3.424.728-.29-1.37zM100.66 46.73l.146 1.393-3.48.366-.147-1.392zM7.674 56.506l.146 1.392-3.48.366-.147-1.392zM100.811 56.873l-.146 1.392-3.48-.365.145-1.393zM7.821 47.101l-.146 1.392-3.48-.365.145-1.393zM100.09 61.895l-.291 1.369-3.424-.728.291-1.369zM8.631 42.46l-.291 1.37-3.423-.728.29-1.37zM98.84 66.827l-.432 1.331-3.329-1.081.433-1.332zM9.918 37.93l-.433 1.331-3.329-1.082.433-1.331zM97.098 71.585l-.569 1.28-3.197-1.424.57-1.28zM11.677 33.558l-.57 1.28-3.197-1.424.57-1.279zM92.149 80.439l-.823 1.133-2.832-2.058.823-1.132zM16.506 25.482l-.823 1.133-2.831-2.057.823-1.133zM89.017 84.431l-.937 1.04-2.6-2.341.936-1.04zM19.528 21.869l-.936 1.04-2.601-2.342.936-1.04zM85.48 88.076l-1.041.936-2.342-2.6 1.04-.937zM22.91 18.59l-1.04.937-2.341-2.601 1.04-.937zM81.574 91.328l-1.133.823-2.057-2.831 1.132-.823zM26.617 15.684l-1.133.823-2.057-2.832 1.132-.823zM72.873 96.524l-1.279.57-1.423-3.198 1.278-.57zM34.838 11.105l-1.279.57-1.423-3.198 1.279-.57zM68.151 98.405l-1.331.432-1.082-3.329 1.332-.432zM39.259 9.485l-1.332.433-1.081-3.33 1.331-.432zM63.272 99.799l-1.369.29-.728-3.422 1.37-.291zM43.83 8.337l-1.369.291-.727-3.423 1.37-.291zM58.27 100.662l-1.393.146-.366-3.48 1.393-.147zM48.494 7.672l-1.392.147-.366-3.481 1.392-.147z\\\"/></g></g></svg>\\n\"","export default \"<svg focusable=\\\"false\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\" viewBox=\\\"0 0 105 105\\\"><path id=\\\"mod_clock_svg_hours\\\" d=\\\"M55.7 64.5h-6.4l.6-44h5.2z\\\"/></svg>\\n\"","export default \"<svg focusable=\\\"false\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\" viewBox=\\\"0 0 105 105\\\"><path d=\\\"M55.1,64.5h-5.2l0.8-58h3.6L55.1,64.5z\\\"/></svg>\\n\"","export default \"<svg focusable=\\\"false\\\" xmlns=\\\"http://www.w3.org/2000/svg\\\" viewBox=\\\"0 0 105 105\\\"><path d=\\\"M57.8,21.3c0-2.9-2.4-5.2-5.2-5.2s-5.3,2.3-5.3,5.2c0,2.7,2,4.8,4.5,5.2V69h1.5V26.5C55.8,26.2,57.8,24,57.8,21.3z\\\"/></svg>\\n\"","import type { CSSResultGroup, PropertyValues, TemplateResult } from 'lit';\nimport { html, isServer, LitElement } from 'lit';\nimport { customElement, property } from 'lit/decorators.js';\nimport { ref } from 'lit/directives/ref.js';\n\nimport type { SbbTime } from '../core/interfaces.ts';\nimport { SbbElementInternalsMixin } from '../core/mixins.ts';\nimport { boxSizingStyles } from '../core/styles.ts';\n\nimport clockFaceSVG from './assets/sbb_clock_face.svg?raw';\nimport clockHandleHoursSVG from './assets/sbb_clock_hours.svg?raw';\nimport clockHandleMinutesSVG from './assets/sbb_clock_minutes.svg?raw';\nimport clockHandleSecondsSVG from './assets/sbb_clock_seconds.svg?raw';\nimport style from './clock.scss?lit&inline';\n\n/** Number of hours on the clock face. */\nconst TOTAL_HOURS_ON_CLOCK_FACE = 12;\n\n/** Number of minutes on the clock face. */\nconst TOTAL_MINUTES_ON_CLOCK_FACE = 60;\n\n/** Number of seconds on the clock face. */\nconst TOTAL_SECONDS_ON_CLOCK_FACE = 60;\n\n/** Timeout for the clock start. */\nconst INITIAL_TIMEOUT_DURATION = 50;\n\n/** Angle in a single rotation. */\nconst FULL_ANGLE = 360;\n\n/** Angle between two consecutive hours: 360/12, means a full rotation / number of hours in a rotation. */\nconst HOURS_ANGLE = 30;\n\n/** Angle between two consecutive minutes: 360/60, means a full rotation / number of minutes in one hour. */\nconst MINUTES_ANGLE = 6;\n\n/** Angle between two consecutive seconds for SBB clock custom behavior. */\nconst SBB_SECONDS_ANGLE = 360 / 58.5;\n\n/** Number of seconds in a minute. */\nconst SECONDS_IN_A_MINUTE = 60;\n\n/** Number of seconds in an hour. */\nconst SECONDS_IN_AN_HOUR = 3600;\n\n/** As a fallback measure, reset the clock every half an hour */\nconst RESET_INTERVAL = SECONDS_IN_AN_HOUR / 2;\n\nconst ADD_EVENT_LISTENER_OPTIONS: AddEventListenerOptions = {\n  once: true,\n  passive: true,\n};\n\n/**\n * It displays an analog clock with the classic SBB face.\n */\nexport\n@customElement('sbb-clock')\nclass SbbClockElement extends SbbElementInternalsMixin(LitElement) {\n  public static override styles: CSSResultGroup = [boxSizingStyles, style];\n\n  /**\n   * Define a specific time which the clock should show statically.\n   * @param value HH:MM:ss\n   */\n  @property() public accessor now: SbbTime | null = null;\n\n  /** Whether the clock is ticking or not */\n  private _state: 'running' | 'paused' = 'paused';\n\n  /** Reference to the hour hand. */\n  private _clockHandHours!: HTMLElement;\n\n  /** Reference to the minute hand. */\n  private _clockHandMinutes!: HTMLElement;\n\n  /** Reference to the second hand. */\n  private _clockHandSeconds!: HTMLElement;\n\n  /** Hours value for the current date. */\n  private _hours!: number;\n\n  /** Minutes value for the current date. */\n  private _minutes!: number;\n\n  /** Seconds value for the current date. */\n  private _seconds!: number;\n\n  /** Move the minutes hand every minute. */\n  private _handMovement?: ReturnType<typeof setInterval>;\n\n  private _resetIntervalId?: ReturnType<typeof setInterval>;\n\n  /** Callback function for hours hand. */\n  private _moveHoursHandFn = (): void => this._moveHoursHand();\n\n  /** Callback function for minutes hand. */\n  private _moveMinutesHandFn = (): void => this._moveMinutesHand();\n\n  public override connectedCallback(): void {\n    super.connectedCallback();\n\n    this._resetIntervalId = setInterval(() => this._resetClock(), RESET_INTERVAL * 1000);\n  }\n\n  protected override willUpdate(changedProperties: PropertyValues<this>): void {\n    super.willUpdate(changedProperties);\n\n    if (!isServer && changedProperties.has('now')) {\n      this._startOrConfigureClock();\n    }\n  }\n\n  protected override firstUpdated(changedProperties: PropertyValues<this>): void {\n    super.firstUpdated(changedProperties);\n\n    if (!isServer) {\n      document.addEventListener('visibilitychange', this._handlePageVisibilityChange, false);\n      this._startOrConfigureClock();\n    }\n  }\n\n  public override disconnectedCallback(): void {\n    super.disconnectedCallback();\n    this._removeEventListeners();\n    clearInterval(this._resetIntervalId);\n  }\n\n  private _handlePageVisibilityChange = async (): Promise<void> => {\n    if (this.now) {\n      return;\n    }\n\n    if (document.visibilityState === 'hidden') {\n      await this._stopClock();\n    } else {\n      await this._startClock();\n    }\n  };\n\n  private async _startOrConfigureClock(): Promise<void> {\n    if (this.now) {\n      await this._stopClock();\n      this._resetSecondsHandAnimation();\n      this._setHandsStartingPosition();\n    } else {\n      await this._startClock();\n    }\n  }\n\n  /** Starts the clock by defining the hands starting position then starting the animations. */\n  private async _startClock(): Promise<void> {\n    this._clockHandHours?.addEventListener(\n      'animationend',\n      this._moveHoursHandFn,\n      ADD_EVENT_LISTENER_OPTIONS,\n    );\n    this._clockHandSeconds?.addEventListener(\n      'animationend',\n      this._moveMinutesHandFn,\n      ADD_EVENT_LISTENER_OPTIONS,\n    );\n\n    await new Promise<void>((resolve) =>\n      setTimeout(() => {\n        this._setHandsStartingPosition();\n\n        this.style?.setProperty('--sbb-clock-animation-play-state', 'running');\n        this._state = 'running';\n        resolve();\n      }, INITIAL_TIMEOUT_DURATION),\n    );\n  }\n\n  /** Stops the clock by removing all the animations. */\n  private async _stopClock(): Promise<void> {\n    clearInterval(this._handMovement);\n\n    this._removeSecondsAnimationStyles();\n    this._removeHoursAnimationStyles();\n\n    this._clockHandHours?.removeEventListener('animationend', this._moveHoursHandFn);\n    this._clockHandSeconds?.removeEventListener('animationend', this._moveMinutesHandFn);\n\n    this._clockHandMinutes?.classList.add('sbb-clock__hand-minutes--no-transition');\n\n    this.style?.setProperty('--sbb-clock-animation-play-state', 'paused');\n    this._state = 'paused';\n  }\n\n  /**\n   * As a fallback measure to prevent de-sync, reset the clock to the system time.\n   */\n  private async _resetClock(): Promise<void> {\n    if (this._state !== 'running') {\n      return;\n    }\n    await this._stopClock();\n    await this._startClock();\n  }\n\n  /** Set the starting position for the three hands on the clock face. */\n  private _setHandsStartingPosition(): void {\n    this._assignCurrentTime();\n    const remainingSeconds = TOTAL_SECONDS_ON_CLOCK_FACE - this._seconds;\n    const remainingMinutes = TOTAL_MINUTES_ON_CLOCK_FACE - this._minutes;\n    const remainingHours = TOTAL_HOURS_ON_CLOCK_FACE - this._hours;\n\n    let hoursAnimationDuration = 0;\n    let hasRemainingMinutesOrSeconds = 0;\n\n    if (remainingSeconds > 0) {\n      hoursAnimationDuration += remainingSeconds;\n      hasRemainingMinutesOrSeconds = 1;\n    }\n\n    if (remainingMinutes > 0) {\n      hoursAnimationDuration +=\n        (remainingMinutes - hasRemainingMinutesOrSeconds) * SECONDS_IN_A_MINUTE;\n      hasRemainingMinutesOrSeconds = 1;\n    }\n\n    if (remainingHours > 0) {\n      hoursAnimationDuration +=\n        (remainingHours - hasRemainingMinutesOrSeconds) * SECONDS_IN_AN_HOUR;\n    }\n\n    this.style?.setProperty(\n      '--sbb-clock-hours-animation-start-angle',\n      `${Math.ceil(this._hours * HOURS_ANGLE + this._minutes / 2)}deg`,\n    );\n    this.style?.setProperty('--sbb-clock-hours-animation-duration', `${hoursAnimationDuration}s`);\n    this.style?.setProperty(\n      '--sbb-clock-seconds-animation-start-angle',\n      `${Math.ceil(this._seconds * SBB_SECONDS_ANGLE)}deg`,\n    );\n    this.style?.setProperty('--sbb-clock-seconds-animation-duration', `${remainingSeconds}s`);\n\n    this._setMinutesHand();\n\n    this._clockHandSeconds?.classList.add('sbb-clock__hand-seconds--initial-minute');\n    this._clockHandHours?.classList.add('sbb-clock__hand-hours--initial-hour');\n\n    this.internals.states.add('initialized');\n  }\n\n  /** Given the current date, calculates the hh/mm/ss values and the hh/mm/ss left to the next midnight. */\n  private _assignCurrentTime(): void {\n    const date = this.now ? null : new Date();\n    const [hours, minutes, seconds] = date\n      ? [date.getHours(), date.getMinutes(), date.getSeconds()]\n      : this.now!.split(':').map((p) => +p);\n\n    this._hours = hours % 12;\n    this._minutes = minutes;\n    this._seconds = seconds;\n  }\n\n  /** Set the starting position for the minutes hand. */\n  private _setMinutesHand(): void {\n    this._clockHandMinutes?.style.setProperty(\n      'transform',\n      `rotateZ(${Math.ceil(this._minutes * MINUTES_ANGLE)}deg)`,\n    );\n  }\n\n  /** Move the hours hand to the next value. */\n  private _moveHoursHand(): void {\n    this._removeHoursAnimationStyles();\n\n    let hoursAngle = Math.ceil(this._hours * HOURS_ANGLE + this._minutes / 2);\n\n    if (hoursAngle >= FULL_ANGLE) {\n      hoursAngle -= FULL_ANGLE;\n    }\n\n    this._clockHandHours?.style.setProperty('transform', `rotateZ(${hoursAngle}deg)`);\n  }\n\n  /** Move the minutes hand to the next value. */\n  private _moveMinutesHand(): void {\n    this._clockHandSeconds?.removeEventListener('animationend', this._moveMinutesHandFn);\n\n    this._removeSecondsAnimationStyles();\n\n    this._addMinutesAndSetHands();\n\n    this._handMovement = setInterval(\n      () => this._addMinutesAndSetHands(),\n      TOTAL_SECONDS_ON_CLOCK_FACE * 1000,\n    );\n  }\n\n  private _addMinutesAndSetHands(): void {\n    this._minutes++;\n    this._setMinutesHand();\n  }\n\n  /**\n   * Removing animation by overriding with empty string,\n   * then triggering a reflow and re add original animation by removing override.\n   * @private\n   */\n  private _resetSecondsHandAnimation(): void {\n    if (!this._clockHandSeconds) {\n      return;\n    }\n    this._clockHandSeconds.style.animation = '';\n    // Hack to trigger reflow\n    // eslint-disable-next-line @typescript-eslint/no-unused-expressions\n    this._clockHandSeconds.offsetHeight;\n    this._clockHandSeconds.style.removeProperty('animation');\n  }\n\n  private _removeEventListeners(): void {\n    document?.removeEventListener('visibilitychange', this._handlePageVisibilityChange);\n    this._clockHandHours?.removeEventListener('animationend', this._moveHoursHandFn);\n    this._clockHandSeconds?.removeEventListener('animationend', this._moveMinutesHandFn);\n    clearInterval(this._handMovement);\n  }\n\n  private _removeHoursAnimationStyles(): void {\n    this._clockHandHours?.classList.remove('sbb-clock__hand-hours--initial-hour');\n    this.style.removeProperty('--sbb-clock-hours-animation-start-angle');\n    this.style.removeProperty('--sbb-clock-hours-animation-duration');\n  }\n\n  private _removeSecondsAnimationStyles(): void {\n    this._clockHandSeconds?.classList.remove('sbb-clock__hand-seconds--initial-minute');\n    this._clockHandMinutes?.classList.remove('sbb-clock__hand-minutes--no-transition');\n    this.style.removeProperty('--sbb-clock-seconds-animation-start-angle');\n    this.style.removeProperty('--sbb-clock-seconds-animation-duration');\n  }\n\n  protected override render(): TemplateResult {\n    return html`\n      <span class=\"sbb-clock__face\" .innerHTML=${clockFaceSVG}></span>\n      <span\n        class=\"sbb-clock__hand-hours\"\n        .innerHTML=${clockHandleHoursSVG}\n        ${ref((e?: Element): void => {\n          this._clockHandHours = e as HTMLSpanElement;\n        })}\n      ></span>\n      <span\n        class=\"sbb-clock__hand-minutes sbb-clock__hand-minutes--no-transition\"\n        .innerHTML=${clockHandleMinutesSVG}\n        ${ref((el?: Element): void => {\n          this._clockHandMinutes = el as HTMLSpanElement;\n        })}\n      ></span>\n      <span\n        class=\"sbb-clock__hand-seconds\"\n        .innerHTML=${clockHandleSecondsSVG}\n        ${ref((el?: Element): void => {\n          this._clockHandSeconds = el as HTMLSpanElement;\n        })}\n      ></span>\n    `;\n  }\n}\n\ndeclare global {\n  interface HTMLElementTagNameMap {\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    'sbb-clock': SbbClockElement;\n  }\n}\n"],"names":[],"mappings":"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"}

package/development/clock.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @entrypoint
+ */
+export * from './clock/clock.component.ts';
+//# sourceMappingURL=clock.d.ts.map

package/development/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../../../src/elements/clock.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,4BAA4B,CAAC"}

package/development/clock.js

@@ -0,0 +1,5 @@
+import { SbbClockElement } from "./clock/clock.component.js";
+export {
+  SbbClockElement
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xvY2suanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOyJ9

package/development/container/container/container.component.d.ts

@@ -0,0 +1,27 @@
+import { CSSResultGroup, LitElement, PropertyValues, TemplateResult } from 'lit';
+declare const SbbContainerElement_base: import('../../core/mixins.ts').AbstractConstructor<import('../../core/mixins.ts').SbbElementInternalsMixinType> & typeof LitElement & import('../../core/mixins.ts').SbbElementInternalsConstructor;
+/**
+ * It displays its content with the default page spacing.
+ *
+ * @slot - Use the unnamed slot to add anything to the container.
+ * @slot sticky-bar - The slot used by the sbb-sticky-bar component.
+ * @slot image - The slot used to slot an `sbb-image` to use as background.
+ */
+export declare class SbbContainerElement extends SbbContainerElement_base {
+    static styles: CSSResultGroup;
+    /** Whether the container is expanded. */
+    accessor expanded: boolean;
+    /** Whether the background color is shown on full container width on large screens. */
+    accessor backgroundExpanded: boolean;
+    /** Color of the container, like transparent, white etc. */
+    accessor color: 'transparent' | 'white' | 'milk' | 'midnight' | 'charcoal';
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'sbb-container': SbbContainerElement;
+    }
+}
+export {};
+//# sourceMappingURL=container.component.d.ts.map

package/development/container/container/container.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.component.d.ts","sourceRoot":"","sources":["../../../../../src/elements/container/container/container.component.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAEnB,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,cAAc,EACpB,MAAM,KAAK,CAAC;;AASb;;;;;;GAMG;AACH,qBAEM,mBAAoB,SAAQ,wBAAoC;IACpE,OAAuB,MAAM,EAAE,cAAc,CAA4B;IAEzE,yCAAyC;IACzC,SAEgB,QAAQ,EAAE,OAAO,CAAS;IAE1C,sFAAsF;IACtF,SAEgB,kBAAkB,EAAE,OAAO,CAAS;IAEpD,2DAA2D;IAC3D,SAA6C,KAAK,EAC9C,aAAa,GACb,OAAO,GACP,MAAM,GACN,UAAU,GACV,UAAU,CAAW;cAEN,UAAU,CAAC,iBAAiB,EAAE,cAAc,CAAC,IAAI,CAAC,GAAG,IAAI;cASzD,MAAM,IAAI,cAAc;CAW5C;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAE7B,eAAe,EAAE,mBAAmB,CAAC;KACtC;CACF"}