@swisspost/internet-header 1.16.5 → 10.1.0

package/dist/cjs/package-E6EPRPpB.js

@@ -0,0 +1,260 @@
+'use strict';
+
+var index = require('./index-B5ypPkK3.js');
+
+const appendToMap = (map, propName, value) => {
+    const items = map.get(propName);
+    if (!items) {
+        map.set(propName, [value]);
+    }
+    else if (!items.includes(value)) {
+        items.push(value);
+    }
+};
+const debounce = (fn, ms) => {
+    let timeoutId;
+    return (...args) => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            timeoutId = 0;
+            fn(...args);
+        }, ms);
+    };
+};
+
+/**
+ * Check if a possible element isConnected.
+ * The property might not be there, so we check for it.
+ *
+ * We want it to return true if isConnected is not a property,
+ * otherwise we would remove these elements and would not update.
+ *
+ * Better leak in Edge than to be useless.
+ */
+const isConnected = (maybeElement) => !('isConnected' in maybeElement) || maybeElement.isConnected;
+const cleanupElements = debounce((map) => {
+    for (let key of map.keys()) {
+        map.set(key, map.get(key).filter(isConnected));
+    }
+}, 2000);
+const stencilSubscription = () => {
+    if (typeof index.getRenderingRef !== 'function') {
+        // If we are not in a stencil project, we do nothing.
+        // This function is not really exported by @stencil/core.
+        return {};
+    }
+    const elmsToUpdate = new Map();
+    return {
+        dispose: () => elmsToUpdate.clear(),
+        get: (propName) => {
+            const elm = index.getRenderingRef();
+            if (elm) {
+                appendToMap(elmsToUpdate, propName, elm);
+            }
+        },
+        set: (propName) => {
+            const elements = elmsToUpdate.get(propName);
+            if (elements) {
+                elmsToUpdate.set(propName, elements.filter(index.forceUpdate));
+            }
+            cleanupElements(elmsToUpdate);
+        },
+        reset: () => {
+            elmsToUpdate.forEach((elms) => elms.forEach(index.forceUpdate));
+            cleanupElements(elmsToUpdate);
+        },
+    };
+};
+
+const unwrap = (val) => (typeof val === 'function' ? val() : val);
+const createObservableMap = (defaultState, shouldUpdate = (a, b) => a !== b) => {
+    const unwrappedState = unwrap(defaultState);
+    let states = new Map(Object.entries(unwrappedState !== null && unwrappedState !== void 0 ? unwrappedState : {}));
+    const handlers = {
+        dispose: [],
+        get: [],
+        set: [],
+        reset: [],
+    };
+    const reset = () => {
+        var _a;
+        // When resetting the state, the default state may be a function - unwrap it to invoke it.
+        // otherwise, the state won't be properly reset
+        states = new Map(Object.entries((_a = unwrap(defaultState)) !== null && _a !== void 0 ? _a : {}));
+        handlers.reset.forEach((cb) => cb());
+    };
+    const dispose = () => {
+        // Call first dispose as resetting the state would
+        // cause less updates ;)
+        handlers.dispose.forEach((cb) => cb());
+        reset();
+    };
+    const get = (propName) => {
+        handlers.get.forEach((cb) => cb(propName));
+        return states.get(propName);
+    };
+    const set = (propName, value) => {
+        const oldValue = states.get(propName);
+        if (shouldUpdate(value, oldValue, propName)) {
+            states.set(propName, value);
+            handlers.set.forEach((cb) => cb(propName, value, oldValue));
+        }
+    };
+    const state = (typeof Proxy === 'undefined'
+        ? {}
+        : new Proxy(unwrappedState, {
+            get(_, propName) {
+                return get(propName);
+            },
+            ownKeys(_) {
+                return Array.from(states.keys());
+            },
+            getOwnPropertyDescriptor() {
+                return {
+                    enumerable: true,
+                    configurable: true,
+                };
+            },
+            has(_, propName) {
+                return states.has(propName);
+            },
+            set(_, propName, value) {
+                set(propName, value);
+                return true;
+            },
+        }));
+    const on = (eventName, callback) => {
+        handlers[eventName].push(callback);
+        return () => {
+            removeFromArray(handlers[eventName], callback);
+        };
+    };
+    const onChange = (propName, cb) => {
+        const unSet = on('set', (key, newValue) => {
+            if (key === propName) {
+                cb(newValue);
+            }
+        });
+        // We need to unwrap the defaultState because it might be a function.
+        // Otherwise we might not be sending the right reset value.
+        const unReset = on('reset', () => cb(unwrap(defaultState)[propName]));
+        return () => {
+            unSet();
+            unReset();
+        };
+    };
+    const use = (...subscriptions) => {
+        const unsubs = subscriptions.reduce((unsubs, subscription) => {
+            if (subscription.set) {
+                unsubs.push(on('set', subscription.set));
+            }
+            if (subscription.get) {
+                unsubs.push(on('get', subscription.get));
+            }
+            if (subscription.reset) {
+                unsubs.push(on('reset', subscription.reset));
+            }
+            if (subscription.dispose) {
+                unsubs.push(on('dispose', subscription.dispose));
+            }
+            return unsubs;
+        }, []);
+        return () => unsubs.forEach((unsub) => unsub());
+    };
+    const forceUpdate = (key) => {
+        const oldValue = states.get(key);
+        handlers.set.forEach((cb) => cb(key, oldValue, oldValue));
+    };
+    return {
+        state,
+        get,
+        set,
+        on,
+        onChange,
+        use,
+        dispose,
+        reset,
+        forceUpdate,
+    };
+};
+const removeFromArray = (array, item) => {
+    const index = array.indexOf(item);
+    if (index >= 0) {
+        array[index] = array[array.length - 1];
+        array.length--;
+    }
+};
+
+const createStore = (defaultState, shouldUpdate) => {
+    const map = createObservableMap(defaultState, shouldUpdate);
+    map.use(stencilSubscription());
+    return map;
+};
+
+const { state, dispose } = createStore({
+    projectId: null,
+    currentLanguage: null,
+    localizedConfig: null,
+    environment: 'prod',
+    activeLink: null,
+    search: true,
+    user: null,
+});
+
+const Link = ({ config, hiddenText, ariaCurrentWhenActive, ...htmlAttributes }) => {
+    const isActive = state.activeLink !== null ? config === state.activeLink : config.active;
+    return (index.h("a", { ...htmlAttributes, href: config.url, "aria-label": config.label, "aria-description": config.description, "aria-current": isActive ? ariaCurrentWhenActive : undefined }, hiddenText ? index.h("span", { class: "visually-hidden" }, config.text) : config.text, 'icon' in config && index.h("post-icon", { "aria-hidden": "true", name: config.icon }), 'image' in config && index.h("img", { src: config.image.src, alt: config.image.alt })));
+};
+
+function createIdFrom(str) {
+    const trimmed = str.trim();
+    if (trimmed === '') {
+        throw new Error('createIdFrom: input string cannot be empty or whitespace only.');
+    }
+    const baseId = trimmed.toLowerCase().replace(/\s+/g, '-');
+    let i = 0;
+    let id = baseId;
+    while (document.getElementById(id)) {
+        id = `${baseId}-${++i}`;
+    }
+    return id;
+}
+
+function getText(item) {
+    return typeof item === 'string' ? item : item.text;
+}
+
+function isLinkConfig(config) {
+    return typeof config !== 'string' && 'url' in config;
+}
+function isInlineTag(tag) {
+    return tag === 'p' || tag === 'span';
+}
+function resolveTextAttributes(config) {
+    if (typeof config === 'string')
+        return { innerHTML: config };
+    return {
+        'innerHTML': config.text,
+        'aria-label': config.label,
+        'aria-description': config.description,
+    };
+}
+const Title = ({ config, tag: TagName = 'p', ...htmlAttributes }) => {
+    if (isLinkConfig(config)) {
+        // Inline tags render the Link directly; heading tags wrap it
+        return isInlineTag(TagName) ? (index.h(Link, { ...htmlAttributes, config: config })) : (index.h(TagName, { ...htmlAttributes }, index.h(Link, { config: config })));
+    }
+    return index.h(TagName, { ...htmlAttributes, ...resolveTextAttributes(config) });
+};
+
+const version = "10.1.0";
+
+exports.Link = Link;
+exports.Title = Title;
+exports.createIdFrom = createIdFrom;
+exports.dispose = dispose;
+exports.getText = getText;
+exports.state = state;
+exports.version = version;

package/dist/cjs/package-MGiZpKVI.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const version = "10.1.0";
+
+exports.version = version;

package/dist/cjs/pattern-BlBN9eIw.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var createValidatorDecorator = require('./create-validator-decorator-CJK3Xf77.js');
+
+/**
+ * Property decorator that validates the property value matches a regular expression.
+ *
+ * Validation runs on `componentDidLoad` and whenever the property value changes.
+ *
+ * @param pattern - The regex pattern the property value must match.
+ */
+function Pattern(pattern) {
+    return createValidatorDecorator.createValidatorDecorator({
+        priority: 1,
+        blocking: false,
+        run(component, property) {
+            const { value, showError } = createValidatorDecorator.getValidationContext(component, property);
+            if (typeof value !== 'string' || !pattern.test(value)) {
+                showError(`must match ${pattern}`);
+                return false;
+            }
+            return true;
+        },
+    });
+}
+
+exports.Pattern = Pattern;

package/dist/cjs/pl-DLfbvgEj.js

@@ -0,0 +1,56 @@
+'use strict';
+
+var _commonjsHelpers = require('./_commonjsHelpers-BJu3ubxk.js');
+
+function _mergeNamespaces(n, m) {
+  m.forEach(function (e) {
+    e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
+      if (k !== 'default' && !(k in n)) {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  });
+  return Object.freeze(n);
+}
+
+var pl$2 = {};
+
+var hasRequiredPl;
+
+function requirePl () {
+	if (hasRequiredPl) return pl$2;
+	hasRequiredPl = 1;
+
+	Object.defineProperty(pl$2, "__esModule", {
+	  value: true
+	});
+	pl$2.default = void 0;
+	var _default = {
+	  days: ['Niedziela', 'Poniedziałek', 'Wtorek', 'Środa', 'Czwartek', 'Piątek', 'Sobota'],
+	  daysShort: ['Nie', 'Pon', 'Wto', 'Śro', 'Czw', 'Pią', 'Sob'],
+	  daysMin: ['Nd', 'Pn', 'Wt', 'Śr', 'Czw', 'Pt', 'So'],
+	  months: ['Styczeń', 'Luty', 'Marzec', 'Kwiecień', 'Maj', 'Czerwiec', 'Lipiec', 'Sierpień', 'Wrzesień', 'Październik', 'Listopad', 'Grudzień'],
+	  monthsShort: ['Sty', 'Lut', 'Mar', 'Kwi', 'Maj', 'Cze', 'Lip', 'Sie', 'Wrz', 'Paź', 'Lis', 'Gru'],
+	  today: 'Dzisiaj',
+	  clear: 'Wyczyść',
+	  dateFormat: 'yyyy-MM-dd',
+	  timeFormat: 'hh:mm:aa',
+	  firstDay: 1
+	};
+	pl$2.default = _default;
+	return pl$2;
+}
+
+var plExports = requirePl();
+var pl = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(plExports);
+
+var pl$1 = /*#__PURE__*/_mergeNamespaces({
+  __proto__: null,
+  default: pl
+}, [plExports]);
+
+exports.pl = pl$1;

package/dist/cjs/placement-qEFR9hmI.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const PLACEMENT_TYPES = [
+    'top',
+    'right',
+    'bottom',
+    'left',
+    'top-start',
+    'top-end',
+    'right-start',
+    'right-end',
+    'bottom-start',
+    'bottom-end',
+    'left-start',
+    'left-end',
+];
+
+exports.PLACEMENT_TYPES = PLACEMENT_TYPES;