@swisspost/design-system-components 10.0.0-next.39 → 10.0.0-next.41

package/dist/cjs/breakpoints-DIH5Oaz7.js

@@ -0,0 +1,186 @@
+'use strict';
+
+/* eslint-disable no-undefined,no-param-reassign,no-shadow */
+
+/**
+ * Throttle execution of a function. Especially useful for rate limiting
+ * execution of handlers on events like resize and scroll.
+ *
+ * @param {number} delay -                  A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher)
+ *                                            are most useful.
+ * @param {Function} callback -               A function to be executed after delay milliseconds. The `this` context and all arguments are passed through,
+ *                                            as-is, to `callback` when the throttled-function is executed.
+ * @param {object} [options] -              An object to configure options.
+ * @param {boolean} [options.noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds
+ *                                            while the throttled-function is being called. If noTrailing is false or unspecified, callback will be executed
+ *                                            one final time after the last throttled-function call. (After the throttled-function has not been called for
+ *                                            `delay` milliseconds, the internal counter is reset).
+ * @param {boolean} [options.noLeading] -   Optional, defaults to false. If noLeading is false, the first throttled-function call will execute callback
+ *                                            immediately. If noLeading is true, the first the callback execution will be skipped. It should be noted that
+ *                                            callback will never executed if both noLeading = true and noTrailing = true.
+ * @param {boolean} [options.debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is
+ *                                            false (at end), schedule `callback` to execute after `delay` ms.
+ *
+ * @returns {Function} A new, throttled, function.
+ */
+function throttle (delay, callback, options) {
+  var _ref = {},
+    _ref$noTrailing = _ref.noTrailing,
+    noTrailing = _ref$noTrailing === void 0 ? false : _ref$noTrailing,
+    _ref$noLeading = _ref.noLeading,
+    noLeading = _ref$noLeading === void 0 ? false : _ref$noLeading,
+    _ref$debounceMode = _ref.debounceMode,
+    debounceMode = _ref$debounceMode === void 0 ? undefined : _ref$debounceMode;
+  /*
+   * After wrapper has stopped being called, this timeout ensures that
+   * `callback` is executed at the proper times in `throttle` and `end`
+   * debounce modes.
+   */
+  var timeoutID;
+  var cancelled = false;
+
+  // Keep track of the last time `callback` was executed.
+  var lastExec = 0;
+
+  // Function to clear existing timeout
+  function clearExistingTimeout() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+  }
+
+  // Function to cancel next exec
+  function cancel(options) {
+    var _ref2 = options || {},
+      _ref2$upcomingOnly = _ref2.upcomingOnly,
+      upcomingOnly = _ref2$upcomingOnly === void 0 ? false : _ref2$upcomingOnly;
+    clearExistingTimeout();
+    cancelled = !upcomingOnly;
+  }
+
+  /*
+   * The `wrapper` function encapsulates all of the throttling / debouncing
+   * functionality and when executed will limit the rate at which `callback`
+   * is executed.
+   */
+  function wrapper() {
+    for (var _len = arguments.length, arguments_ = new Array(_len), _key = 0; _key < _len; _key++) {
+      arguments_[_key] = arguments[_key];
+    }
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    if (cancelled) {
+      return;
+    }
+
+    // Execute `callback` and update the `lastExec` timestamp.
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, arguments_);
+    }
+
+    /*
+     * If `debounceMode` is true (at begin) this is used to clear the flag
+     * to allow future `callback` executions.
+     */
+    function clear() {
+      timeoutID = undefined;
+    }
+    if (!noLeading && debounceMode && !timeoutID) {
+      /*
+       * Since `wrapper` is being called for the first time and
+       * `debounceMode` is true (at begin), execute `callback`
+       * and noLeading != true.
+       */
+      exec();
+    }
+    clearExistingTimeout();
+    if (debounceMode === undefined && elapsed > delay) {
+      if (noLeading) {
+        /*
+         * In throttle mode with noLeading, if `delay` time has
+         * been exceeded, update `lastExec` and schedule `callback`
+         * to execute after `delay` ms.
+         */
+        lastExec = Date.now();
+        if (!noTrailing) {
+          timeoutID = setTimeout(debounceMode ? clear : exec, delay);
+        }
+      } else {
+        /*
+         * In throttle mode without noLeading, if `delay` time has been exceeded, execute
+         * `callback`.
+         */
+        exec();
+      }
+    } else if (noTrailing !== true) {
+      /*
+       * In trailing throttle mode, since `delay` time has not been
+       * exceeded, schedule `callback` to execute `delay` ms after most
+       * recent execution.
+       *
+       * If `debounceMode` is true (at begin), schedule `clear` to execute
+       * after `delay` ms.
+       *
+       * If `debounceMode` is false (at end), schedule `callback` to
+       * execute after `delay` ms.
+       */
+      timeoutID = setTimeout(debounceMode ? clear : exec, debounceMode === undefined ? delay - elapsed : delay);
+    }
+  }
+  wrapper.cancel = cancel;
+
+  // Return the wrapper function.
+  return wrapper;
+}
+
+const IS_SERVER = typeof window === 'undefined';
+const IS_BROWSER = !IS_SERVER;
+
+class Breakpoint {
+    constructor() {
+        this.updateCurrentBreakpoint = throttle(50, (options = { emitEvents: true }) => {
+            const previousBreakpoint = this.currentBreakpoint;
+            this.currentBreakpoint = this.breakpoints.find(breakpoint => {
+                return breakpoint.minWidth <= innerWidth;
+            });
+            if (!this.currentBreakpoint || !options.emitEvents)
+                return;
+            Object.keys(this.currentBreakpoint)
+                .filter(key => !previousBreakpoint || this.currentBreakpoint[key] !== previousBreakpoint[key])
+                .forEach((key) => this.dispatchEvent(key));
+        });
+        if (IS_SERVER || !!this.breakpoints)
+            return;
+        const keys = this.getValues('--post-grid-breakpoint-keys');
+        const devices = this.getValues('--post-grid-breakpoint-devices');
+        const widths = this.getValues('--post-grid-breakpoint-widths');
+        this.breakpoints = widths
+            .map((width, i) => ({
+            key: keys[i],
+            device: devices[i],
+            minWidth: Number(width),
+        }))
+            .sort((a, b) => b.minWidth - a.minWidth);
+        this.updateCurrentBreakpoint({ emitEvents: false });
+        window.addEventListener('resize', () => this.updateCurrentBreakpoint(), { passive: true });
+    }
+    getValues(cssCustomProperty) {
+        const values = getComputedStyle(document.documentElement).getPropertyValue(cssCustomProperty);
+        return values ? values.split(',').map(v => v.trim()) : [];
+    }
+    dispatchEvent(property) {
+        if (IS_SERVER)
+            return;
+        window.dispatchEvent(new CustomEvent(`postBreakpoint:${property}`, { detail: this.currentBreakpoint[property] }));
+    }
+    get(property) {
+        this.updateCurrentBreakpoint({ emitEvents: false });
+        return this.currentBreakpoint[property];
+    }
+}
+const breakpoint = new Breakpoint();
+
+exports.IS_BROWSER = IS_BROWSER;
+exports.breakpoint = breakpoint;
+exports.throttle = throttle;

package/dist/cjs/event-from-AKK8RQrn.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * Validates if an event should be processed based on target and nesting criteria
+ * @param event - The event to validate
+ * @param tag - The expected local name of the event target
+ * @param host - The host element for nested component checking
+ * @param ignoreNestedComponents - Whether to ignore events from nested components
+ * @returns true if the event should be processed, false otherwise
+ */
+function shouldProcessEvent(event, tag, host, ignoreNestedComponents) {
+    if (!(event instanceof CustomEvent && event.target instanceof HTMLElement))
+        return false;
+    const eventTarget = event.target;
+    if (eventTarget.localName !== tag)
+        return false;
+    if (ignoreNestedComponents) {
+        // Find the closest parent with the same tag as the host
+        const closestParentWithSameTag = findClosestParentWithTag(eventTarget, host.localName);
+        if (closestParentWithSameTag !== host)
+            return false;
+    }
+    return true;
+}
+/**
+ * Decorator that guards event handlers to only execute when the event meets certain criteria.
+ * @param tag - The local name of the element that should be the target of the event
+ * @param option - Configuration options for the event guard
+ * @param option.ignoreNestedComponents - Whether to ignore events from nested components
+ */
+function EventFrom(tag, option = { ignoreNestedComponents: true }) {
+    return function (target, propertyKey, descriptor) {
+        if (descriptor) {
+            const originalMethod = descriptor.value;
+            descriptor.value = function (event) {
+                if (!shouldProcessEvent(event, tag, this.host, option.ignoreNestedComponents)) {
+                    return;
+                }
+                return originalMethod.call(this, event);
+            };
+        }
+        else {
+            // Creates a hidden storage property for the original method using a 
+            // modified key format (__[property]_original) to avoid naming conflicts
+            const privateKey = `__${propertyKey}_original`;
+            // Create hidden storage for original method
+            Object.defineProperty(target, privateKey, {
+                writable: true,
+                configurable: true
+            });
+            // Replace property with getter/setter
+            Object.defineProperty(target, propertyKey, {
+                // Getter returns original method
+                get() {
+                    return this[privateKey];
+                },
+                // Setter wraps original method with extra code
+                set(originalFunction) {
+                    if (typeof originalFunction === 'function') {
+                        // Store original and add new behavior
+                        this[privateKey] = (event) => {
+                            if (!shouldProcessEvent(event, tag, this.host, option.ignoreNestedComponents)) {
+                                return;
+                            }
+                            return originalFunction.call(this, event);
+                        };
+                    }
+                    else {
+                        this[privateKey] = originalFunction;
+                    }
+                },
+                configurable: true,
+                enumerable: true
+            });
+        }
+    };
+}
+/**
+ * Traverses up the DOM (including crossing shadow DOM boundaries) to find the closest ancestor
+ * that matches the specified tag name.
+ * @param element - The starting element
+ * @param tagName - The tag name to match (e.g., 'post-accordion')
+ * @returns The closest matching ancestor or null if none found
+ */
+function findClosestParentWithTag(element, tagName) {
+    let current = element;
+    while (current) {
+        if (current.localName === tagName) {
+            return current;
+        }
+        // Check regular parent first
+        if (current.parentElement) {
+            current = current.parentElement;
+        }
+        // If no parentElement, check if we're in a shadow root
+        else if (current.parentNode instanceof ShadowRoot) {
+            current = current.parentNode.host;
+        }
+        // No more parents to check
+        else {
+            current = null;
+        }
+    }
+    return null;
+}
+
+exports.EventFrom = EventFrom;

package/dist/cjs/{get-root-8102fecd.js → get-root-DmyBVSJ_.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const breakpoints = require('./breakpoints-cdf1b747.js');
+var breakpoints = require('./breakpoints-DIH5Oaz7.js');
 
 /**
  * getRootNode() can only be used after the element has been attached to the document!