@swisspost/design-system-components 9.0.0-next.2 → 9.0.0-next.21

package/dist/types/home/runner/work/design-system/design-system/packages/components/.stencil/.config/bindings.angular.d.ts

@@ -0,0 +1,2 @@
+import { ValueAccessorConfig } from '@stencil/angular-output-target';
+export declare const angularValueAccessorBindings: ValueAccessorConfig[];

package/dist/types/index.d.ts

@@ -1,17 +1,36 @@
-export { Components, JSX } from './components';
+export { Components, JSX, PostHeaderCustomEvent } from './components';
 export { PostAccordion } from './components/post-accordion/post-accordion';
 export { PostAccordionItem } from './components/post-accordion-item/post-accordion-item';
-export { PostAlert } from './components/post-alert/post-alert';
+export { PostAvatar } from './components/post-avatar/post-avatar';
+export { PostBackToTop } from './components/post-back-to-top/post-back-to-top';
+export { PostBanner } from './components/post-banner/post-banner';
+export { PostBreadcrumb } from './components/post-breadcrumb/post-breadcrumb';
+export { PostBreadcrumbItem } from './components/post-breadcrumb-item/post-breadcrumb-item';
 export { PostCardControl } from './components/post-card-control/post-card-control';
+export { PostClosebutton } from './components/post-closebutton/post-closebutton';
 export { PostCollapsible } from './components/post-collapsible/post-collapsible';
 export { PostCollapsibleTrigger } from './components/post-collapsible-trigger/post-collapsible-trigger';
+export { PostFooter } from './components/post-footer/post-footer';
+export { PostHeader, DEVICE_SIZE } from './components/post-header/post-header';
 export { PostIcon } from './components/post-icon/post-icon';
+export { PostLanguageOption } from './components/post-language-option/post-language-option';
+export { PostLanguageSwitch } from './components/post-language-switch/post-language-switch';
+export { PostLinkarea } from './components/post-linkarea/post-linkarea';
+export { PostList } from './components/post-list/post-list';
+export { PostListItem } from './components/post-list-item/post-list-item';
 export { PostLogo } from './components/post-logo/post-logo';
+export { PostMainnavigation } from './components/post-mainnavigation/post-mainnavigation';
+export { PostMegadropdown } from './components/post-megadropdown/post-megadropdown';
+export { PostMegadropdownTrigger } from './components/post-megadropdown-trigger/post-megadropdown-trigger';
+export { PostMenu } from './components/post-menu/post-menu';
+export { PostMenuItem } from './components/post-menu-item/post-menu-item';
+export { PostMenuTrigger } from './components/post-menu-trigger/post-menu-trigger';
 export { PostPopover } from './components/post-popover/post-popover';
 export { PostPopovercontainer } from './components/post-popovercontainer/post-popovercontainer';
 export { PostRating } from './components/post-rating/post-rating';
 export { PostTabs } from './components/post-tabs/post-tabs';
 export { PostTabHeader } from './components/post-tab-header/post-tab-header';
 export { PostTabPanel } from './components/post-tab-panel/post-tab-panel';
-export { PostTooltip } from './components/post-tooltip/post-tooltip';
 export { PostTag } from './components/post-tag/post-tag';
+export { PostTogglebutton } from './components/post-togglebutton/post-togglebutton';
+export { PostTooltip } from './components/post-tooltip/post-tooltip';

package/dist/types/utils/attribute-observer.d.ts

@@ -1 +1 @@
-export declare const getAttributeObserver: (attribute: string, handler: (element: HTMLElement, mutation?: MutationRecord) => void) => MutationObserver;
+export declare function getAttributeObserver(attribute: string, handler: (element: HTMLElement, mutation?: MutationRecord) => void): MutationObserver;

package/dist/types/utils/breakpoints.d.ts

@@ -0,0 +1,12 @@
+type ListenerType = 'key' | 'name';
+export declare class Breakpoint {
+    private readonly breakpointMap;
+    private readonly current;
+    constructor();
+    private getStyles;
+    private updateHandler;
+    private dispatchEvent;
+    get(type: ListenerType): string;
+}
+export declare const breakpoint: Breakpoint;
+export {};

package/dist/types/utils/component-on-ready.d.ts

@@ -3,4 +3,4 @@ import { HostElement } from '../stencil-public-runtime';
  * Invoke the `componentOnReady` method if it is available, simulate it otherwise
  * @see https://stenciljs.com/docs/api#componentonready
  */
-export declare const componentOnReady: <T extends HostElement>(el: T) => Promise<T>;
+export declare function componentOnReady<T extends HostElement>(el: T): Promise<T>;

package/dist/types/utils/get-focusable-children.d.ts

@@ -0,0 +1 @@
+export declare function getFocusableChildren(element: Element): HTMLElement[];

package/dist/types/utils/get-root.d.ts

@@ -1 +1 @@
-export declare function getRoot(element: HTMLElement): Document | ShadowRoot;
+export declare function getRoot(element: Element): Document | ShadowRoot;

package/dist/types/utils/property-checkers/check-non-empty.d.ts

@@ -1 +1,3 @@
-export declare function checkNonEmpty(value: unknown, error: string): void;
+export declare function checkNonEmpty<T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, customMessage?: string): void;

package/dist/types/utils/property-checkers/check-one-of.d.ts

@@ -1 +1,3 @@
-export declare function checkOneOf<T>(value: T, possibleValues: readonly T[], error: string): void;
+export declare function checkOneOf<T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, possibleValues: readonly unknown[], customMessage?: string): void;

package/dist/types/utils/property-checkers/check-pattern.d.ts

@@ -1 +1,3 @@
-export declare function checkPattern(value: unknown, pattern: RegExp, errorMessage: string): void;
+export declare function checkPattern<T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, pattern: RegExp, customMessage: string): void;

package/dist/types/utils/property-checkers/check-type.d.ts

@@ -1,2 +1,4 @@
 export type PropertyType = 'boolean' | 'number' | 'string' | 'array' | 'object' | 'function';
-export declare function checkType(value: unknown, type: PropertyType, error: string): void;
+export declare function checkType<T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, type: PropertyType, customMessage?: string): void;

package/dist/types/utils/property-checkers/check-url.d.ts

@@ -1 +1,3 @@
-export declare function checkUrl(value: unknown, error: string): void;
+export declare function checkUrl<T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, customMessage?: string): void;

package/dist/types/utils/property-checkers/index.d.ts

@@ -1,7 +1,15 @@
-export declare const checkEmptyOrOneOf: <T>(value: T, possibleValues: readonly T[], error: string) => void;
-export declare const checkEmptyOrPattern: (value: unknown, pattern: RegExp, errorMessage: string) => void;
-export declare const checkEmptyOrType: (value: unknown, type: import("./check-type").PropertyType, error: string) => void;
-export declare const checkEmptyOrUrl: (value: unknown, error: string) => void;
+export declare const checkEmptyOrOneOf: <T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, possibleValues: readonly unknown[], customMessage?: string) => void;
+export declare const checkEmptyOrPattern: <T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, pattern: RegExp, customMessage: string) => void;
+export declare const checkEmptyOrType: <T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, type: import("./check-type").PropertyType, customMessage?: string) => void;
+export declare const checkEmptyOrUrl: <T extends {
+    host: HTMLElement;
+}>(component: T, prop: keyof T, customMessage?: string) => void;
 export * from './check-non-empty';
 export * from './check-one-of';
 export * from './check-pattern';

package/dist/types/utils/sass-export.d.ts

@@ -1,2 +1,6 @@
-export declare function parse(scss: object): {};
+type Scss = {
+    [key: string]: string;
+};
+export declare function parse(scss: Scss): {};
 export declare function formatAsMap(obj: object): string;
+export {};

package/loaders/attribute-observer.js

@@ -1,9 +1,9 @@
-const getAttributeObserver = (attribute, handler) => {
+function getAttributeObserver(attribute, handler) {
     /**
      * Handle attribute changes and childList changes from the observer
      * @param {MutationRecord[]} mutationList
      */
-    const observerHandler = (mutationList) => {
+    function observerHandler(mutationList) {
         mutationList.forEach(mutation => {
             if (mutation.type === 'attributes' && mutation.attributeName === attribute) {
                 handler(mutation.target);
@@ -17,9 +17,9 @@ const getAttributeObserver = (attribute, handler) => {
                 });
             }
         });
-    };
+    }
     // Initialize a mutation observer for patching accessibility features
     return new MutationObserver(observerHandler);
-};
+}
 
 export { getAttributeObserver as g };

package/loaders/check-non-empty.js

@@ -1,8 +1,12 @@
 import { E as EMPTY_VALUES } from './constants.js';
 
-function checkNonEmpty(value, error) {
+function checkNonEmpty(component, prop, customMessage) {
+    const componentName = component.host.localName;
+    const value = component[prop];
+    const defaultMessage = `The prop \`${String(prop)}\` of the \`${componentName}\` component is required.`;
+    const message = customMessage || defaultMessage;
     if (EMPTY_VALUES.some(v => v === value)) {
-        throw new Error(error);
+        throw new Error(message);
     }
 }
 

package/loaders/check-one-of.js

@@ -1,6 +1,11 @@
-function checkOneOf(value, possibleValues, error) {
-    if (!possibleValues.includes(value))
-        throw new Error(error);
+function checkOneOf(component, prop, possibleValues, customMessage) {
+    const componentName = component.host.localName;
+    const value = component[prop];
+    const defaultMessage = `The prop \`${String(prop)}\` of the \`${componentName}\` component must be one of the following values: ${possibleValues.join(', ')}.`;
+    const message = customMessage || defaultMessage;
+    if (!possibleValues.includes(value)) {
+        throw new Error(message);
+    }
 }
 
 export { checkOneOf as c };

package/loaders/check-type.js

@@ -1,13 +1,18 @@
-function checkType(value, type, error) {
+function checkType(component, prop, type, customMessage) {
+    const componentName = component.host.localName;
+    const value = component[prop];
     const typeIsArray = type === 'array';
     const valueIsArray = Array.isArray(value);
+    const defaultMessage = `The prop \`${String(prop)}\` of the \`${componentName}\` component must be of type \`
+    ${type}\`.`;
+    const message = customMessage || defaultMessage;
     if (typeIsArray || valueIsArray) {
-        if (valueIsArray !== typeIsArray)
-            throw new Error(error);
+        if (valueIsArray !== typeIsArray) {
+            throw new Error(message);
+        }
     }
-    else {
-        if (typeof value !== type)
-            throw new Error(error);
+    else if (typeof value !== type) {
+        throw new Error(message);
     }
 }
 

package/loaders/debounce.js

@@ -0,0 +1,11 @@
+function debounce(callback, timeout = 200) {
+    let id;
+    return (...args) => {
+        if (id) {
+            clearTimeout(id);
+        }
+        id = setTimeout(callback, timeout, ...args);
+    };
+}
+
+export { debounce as d };

package/loaders/fade.js

@@ -1,7 +1,11 @@
 const fadeDuration = 200;
 const fadedOutKeyframe = { opacity: '0' };
 const fadedInKeyframe = { opacity: '1' };
-const fadeIn = (el) => el.animate([fadedOutKeyframe, fadedInKeyframe], { duration: fadeDuration });
-const fadeOut = (el) => el.animate([fadedInKeyframe, fadedOutKeyframe], { duration: fadeDuration });
+function fadeIn(el) {
+    return el.animate([fadedOutKeyframe, fadedInKeyframe], { duration: fadeDuration });
+}
+function fadeOut(el) {
+    return el.animate([fadedInKeyframe, fadedOutKeyframe], { duration: fadeDuration });
+}
 
 export { fadeIn as a, fadeOut as f };

package/loaders/get-focusable-children.js

@@ -0,0 +1,35 @@
+const focusableSelector = `:where(${[
+    'button',
+    'input:not([type="hidden"])',
+    '[tabindex]',
+    'select',
+    'textarea',
+    '[contenteditable]',
+    'a[href]',
+    'iframe',
+    'audio[controls]',
+    'video[controls]',
+    'area[href]',
+    'details > summary:first-of-type',
+].join(',')})`;
+const focusDisablingSelector = `:where(${[
+    '[inert]',
+    '[inert] *',
+    ':disabled',
+    'dialog:not([open]) *',
+    '[popover]:not(:popover-open) *',
+    'details:not([open]) > *:not(details > summary:first-of-type)',
+    'details:not([open]) > *:not(details > summary:first-of-type) *',
+    '[tabindex^="-"]',
+    '[hidden]:not([hidden="false"])',
+].join(',')})`;
+function getFocusableChildren(element) {
+    const focusableChildren = element.querySelectorAll(`${focusableSelector}:not(${focusDisablingSelector})`);
+    const visibleFocusableChildren = Array.from(focusableChildren).filter(child => {
+        const style = window.getComputedStyle(child.parentElement);
+        return style.display !== 'none' && style.visibility !== 'hidden';
+    });
+    return visibleFocusableChildren;
+}
+
+export { getFocusableChildren as g };

package/loaders/get-root.js

@@ -0,0 +1,9 @@
+function getRoot(element) {
+    const root = element.getRootNode();
+    if (root instanceof Document || root instanceof ShadowRoot) {
+        return root;
+    }
+    throw new Error('Attempting to access root node before the element is attached to the document or shadow tree.');
+}
+
+export { getRoot as g };

package/loaders/index.browser.js

@@ -0,0 +1,13 @@
+const urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
+let nanoid = (size = 21) => {
+  let id = '';
+  let bytes = crypto.getRandomValues(new Uint8Array((size |= 0)));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id
+};
+
+export { nanoid as n };

package/loaders/index.d.ts

@@ -3,18 +3,54 @@ export { PostAccordion as PostAccordion } from '../dist/types/components/post-ac
 export { defineCustomElement as defineCustomElementPostAccordion } from './post-accordion';
 export { PostAccordionItem as PostAccordionItem } from '../dist/types/components/post-accordion-item/post-accordion-item';
 export { defineCustomElement as defineCustomElementPostAccordionItem } from './post-accordion-item';
-export { PostAlert as PostAlert } from '../dist/types/components/post-alert/post-alert';
-export { defineCustomElement as defineCustomElementPostAlert } from './post-alert';
+export { PostAvatar as PostAvatar } from '../dist/types/components/post-avatar/post-avatar';
+export { defineCustomElement as defineCustomElementPostAvatar } from './post-avatar';
+export { PostBackToTop as PostBackToTop } from '../dist/types/components/post-back-to-top/post-back-to-top';
+export { defineCustomElement as defineCustomElementPostBackToTop } from './post-back-to-top';
+export { PostBanner as PostBanner } from '../dist/types/components/post-banner/post-banner';
+export { defineCustomElement as defineCustomElementPostBanner } from './post-banner';
+export { PostBreadcrumb as PostBreadcrumb } from '../dist/types/components/post-breadcrumb/post-breadcrumb';
+export { defineCustomElement as defineCustomElementPostBreadcrumb } from './post-breadcrumb';
+export { PostBreadcrumbItem as PostBreadcrumbItem } from '../dist/types/components/post-breadcrumb-item/post-breadcrumb-item';
+export { defineCustomElement as defineCustomElementPostBreadcrumbItem } from './post-breadcrumb-item';
 export { PostCardControl as PostCardControl } from '../dist/types/components/post-card-control/post-card-control';
 export { defineCustomElement as defineCustomElementPostCardControl } from './post-card-control';
+export { PostClosebutton as PostClosebutton } from '../dist/types/components/post-closebutton/post-closebutton';
+export { defineCustomElement as defineCustomElementPostClosebutton } from './post-closebutton';
 export { PostCollapsible as PostCollapsible } from '../dist/types/components/post-collapsible/post-collapsible';
 export { defineCustomElement as defineCustomElementPostCollapsible } from './post-collapsible';
 export { PostCollapsibleTrigger as PostCollapsibleTrigger } from '../dist/types/components/post-collapsible-trigger/post-collapsible-trigger';
 export { defineCustomElement as defineCustomElementPostCollapsibleTrigger } from './post-collapsible-trigger';
+export { PostFooter as PostFooter } from '../dist/types/components/post-footer/post-footer';
+export { defineCustomElement as defineCustomElementPostFooter } from './post-footer';
+export { PostHeader as PostHeader } from '../dist/types/components/post-header/post-header';
+export { defineCustomElement as defineCustomElementPostHeader } from './post-header';
 export { PostIcon as PostIcon } from '../dist/types/components/post-icon/post-icon';
 export { defineCustomElement as defineCustomElementPostIcon } from './post-icon';
+export { PostLanguageOption as PostLanguageOption } from '../dist/types/components/post-language-option/post-language-option';
+export { defineCustomElement as defineCustomElementPostLanguageOption } from './post-language-option';
+export { PostLanguageSwitch as PostLanguageSwitch } from '../dist/types/components/post-language-switch/post-language-switch';
+export { defineCustomElement as defineCustomElementPostLanguageSwitch } from './post-language-switch';
+export { PostLinkarea as PostLinkarea } from '../dist/types/components/post-linkarea/post-linkarea';
+export { defineCustomElement as defineCustomElementPostLinkarea } from './post-linkarea';
+export { PostList as PostList } from '../dist/types/components/post-list/post-list';
+export { defineCustomElement as defineCustomElementPostList } from './post-list';
+export { PostListItem as PostListItem } from '../dist/types/components/post-list-item/post-list-item';
+export { defineCustomElement as defineCustomElementPostListItem } from './post-list-item';
 export { PostLogo as PostLogo } from '../dist/types/components/post-logo/post-logo';
 export { defineCustomElement as defineCustomElementPostLogo } from './post-logo';
+export { PostMainnavigation as PostMainnavigation } from '../dist/types/components/post-mainnavigation/post-mainnavigation';
+export { defineCustomElement as defineCustomElementPostMainnavigation } from './post-mainnavigation';
+export { PostMegadropdown as PostMegadropdown } from '../dist/types/components/post-megadropdown/post-megadropdown';
+export { defineCustomElement as defineCustomElementPostMegadropdown } from './post-megadropdown';
+export { PostMegadropdownTrigger as PostMegadropdownTrigger } from '../dist/types/components/post-megadropdown-trigger/post-megadropdown-trigger';
+export { defineCustomElement as defineCustomElementPostMegadropdownTrigger } from './post-megadropdown-trigger';
+export { PostMenu as PostMenu } from '../dist/types/components/post-menu/post-menu';
+export { defineCustomElement as defineCustomElementPostMenu } from './post-menu';
+export { PostMenuItem as PostMenuItem } from '../dist/types/components/post-menu-item/post-menu-item';
+export { defineCustomElement as defineCustomElementPostMenuItem } from './post-menu-item';
+export { PostMenuTrigger as PostMenuTrigger } from '../dist/types/components/post-menu-trigger/post-menu-trigger';
+export { defineCustomElement as defineCustomElementPostMenuTrigger } from './post-menu-trigger';
 export { PostPopover as PostPopover } from '../dist/types/components/post-popover/post-popover';
 export { defineCustomElement as defineCustomElementPostPopover } from './post-popover';
 export { PostPopovercontainer as PostPopovercontainer } from '../dist/types/components/post-popovercontainer/post-popovercontainer';
@@ -29,6 +65,8 @@ export { PostTabs as PostTabs } from '../dist/types/components/post-tabs/post-ta
 export { defineCustomElement as defineCustomElementPostTabs } from './post-tabs';
 export { PostTag as PostTag } from '../dist/types/components/post-tag/post-tag';
 export { defineCustomElement as defineCustomElementPostTag } from './post-tag';
+export { PostTogglebutton as PostTogglebutton } from '../dist/types/components/post-togglebutton/post-togglebutton';
+export { defineCustomElement as defineCustomElementPostTogglebutton } from './post-togglebutton';
 export { PostTooltip as PostTooltip } from '../dist/types/components/post-tooltip/post-tooltip';
 export { defineCustomElement as defineCustomElementPostTooltip } from './post-tooltip';
 

package/loaders/index.js

@@ -1,18 +1,37 @@
 export { getAssetPath, setAssetPath, setNonce, setPlatformOptions } from '@stencil/core/internal/client';
-export { PostPopover, defineCustomElement as defineCustomElementPostPopover } from './post-popover.js';
+export { PostAvatar, defineCustomElement as defineCustomElementPostAvatar } from './post-avatar.js';
 import './post-popovercontainer2.js';
+export { PostFooter, defineCustomElement as defineCustomElementPostFooter } from './post-footer.js';
+export { PostPopover, defineCustomElement as defineCustomElementPostPopover } from './post-popover.js';
 export { PostTooltip, defineCustomElement as defineCustomElementPostTooltip } from './post-tooltip.js';
 export { PostAccordion, defineCustomElement as defineCustomElementPostAccordion } from './post-accordion.js';
 export { PostAccordionItem, defineCustomElement as defineCustomElementPostAccordionItem } from './post-accordion-item.js';
-export { PostAlert, defineCustomElement as defineCustomElementPostAlert } from './post-alert.js';
+export { PostBackToTop, defineCustomElement as defineCustomElementPostBackToTop } from './post-back-to-top.js';
+export { PostBanner, defineCustomElement as defineCustomElementPostBanner } from './post-banner.js';
+export { PostBreadcrumb, defineCustomElement as defineCustomElementPostBreadcrumb } from './post-breadcrumb.js';
+export { PostBreadcrumbItem, defineCustomElement as defineCustomElementPostBreadcrumbItem } from './post-breadcrumb-item.js';
 export { PostCardControl, defineCustomElement as defineCustomElementPostCardControl } from './post-card-control.js';
+export { PostClosebutton, defineCustomElement as defineCustomElementPostClosebutton } from './post-closebutton.js';
 export { PostCollapsible, defineCustomElement as defineCustomElementPostCollapsible } from './post-collapsible.js';
 export { PostCollapsibleTrigger, defineCustomElement as defineCustomElementPostCollapsibleTrigger } from './post-collapsible-trigger.js';
+export { PostHeader, defineCustomElement as defineCustomElementPostHeader } from './post-header.js';
 export { PostIcon, defineCustomElement as defineCustomElementPostIcon } from './post-icon.js';
+export { PostLanguageOption, defineCustomElement as defineCustomElementPostLanguageOption } from './post-language-option.js';
+export { PostLanguageSwitch, defineCustomElement as defineCustomElementPostLanguageSwitch } from './post-language-switch.js';
+export { PostLinkarea, defineCustomElement as defineCustomElementPostLinkarea } from './post-linkarea.js';
+export { PostList, defineCustomElement as defineCustomElementPostList } from './post-list.js';
+export { PostListItem, defineCustomElement as defineCustomElementPostListItem } from './post-list-item.js';
 export { PostLogo, defineCustomElement as defineCustomElementPostLogo } from './post-logo.js';
+export { PostMainnavigation, defineCustomElement as defineCustomElementPostMainnavigation } from './post-mainnavigation.js';
+export { PostMegadropdown, defineCustomElement as defineCustomElementPostMegadropdown } from './post-megadropdown.js';
+export { PostMegadropdownTrigger, defineCustomElement as defineCustomElementPostMegadropdownTrigger } from './post-megadropdown-trigger.js';
+export { PostMenu, defineCustomElement as defineCustomElementPostMenu } from './post-menu.js';
+export { PostMenuItem, defineCustomElement as defineCustomElementPostMenuItem } from './post-menu-item.js';
+export { PostMenuTrigger, defineCustomElement as defineCustomElementPostMenuTrigger } from './post-menu-trigger.js';
 export { PostPopovercontainer, defineCustomElement as defineCustomElementPostPopovercontainer } from './post-popovercontainer.js';
 export { PostRating, defineCustomElement as defineCustomElementPostRating } from './post-rating.js';
 export { PostTabHeader, defineCustomElement as defineCustomElementPostTabHeader } from './post-tab-header.js';
 export { PostTabPanel, defineCustomElement as defineCustomElementPostTabPanel } from './post-tab-panel.js';
 export { PostTabs, defineCustomElement as defineCustomElementPostTabs } from './post-tabs.js';
 export { PostTag, defineCustomElement as defineCustomElementPostTag } from './post-tag.js';
+export { PostTogglebutton, defineCustomElement as defineCustomElementPostTogglebutton } from './post-togglebutton.js';

package/loaders/index2.js

@@ -4,25 +4,38 @@ import { c as checkType } from './check-type.js';
 
 function emptyOr(check) {
     return (...args) => {
-        const value = args[0];
-        if (!EMPTY_VALUES.some(v => v === value))
+        const component = args[0];
+        const prop = args[1];
+        const value = component[prop];
+        if (!EMPTY_VALUES.some(v => v === value)) {
             check(...args);
+        }
     };
 }
 
-function checkPattern(value, pattern, errorMessage) {
-    if (typeof value !== 'string' || !pattern.test(value))
-        throw new Error(errorMessage);
+function checkPattern(component, prop, pattern, customMessage) {
+    const componentName = component.host.localName;
+    const value = component[prop];
+    const defaultMessage = `The prop \`${String(prop)}\` of the \`${componentName}\` component must be follow the format \`${pattern}\`.`;
+    const message = customMessage || defaultMessage;
+    if (typeof value !== 'string' || !pattern.test(value)) {
+        throw new Error(message);
+    }
 }
 
-function checkUrl(value, error) {
-    if (typeof value !== 'string' && !(value instanceof URL))
-        throw new Error(error);
+function checkUrl(component, prop, customMessage) {
+    const componentName = component.host.localName;
+    const value = component[prop];
+    const defaultMessage = `The prop \`${String(prop)}\` of the \`${componentName}\` component is invalid.`;
+    const message = customMessage || defaultMessage;
+    if (typeof value !== 'string' && !(value instanceof URL)) {
+        throw new Error(message);
+    }
     try {
-        new URL(value);
+        new URL(value, 'https://www.post.ch');
     }
-    catch (e) {
-        throw new Error(error);
+    catch {
+        throw new Error(message);
     }
 }
 
@@ -31,4 +44,4 @@ const checkEmptyOrPattern = emptyOr(checkPattern);
 const checkEmptyOrType = emptyOr(checkType);
 const checkEmptyOrUrl = emptyOr(checkUrl);
 
-export { checkEmptyOrOneOf as a, checkEmptyOrPattern as b, checkEmptyOrType as c, checkEmptyOrUrl as d };
+export { checkEmptyOrPattern as a, checkEmptyOrOneOf as b, checkEmptyOrType as c, checkUrl as d, checkEmptyOrUrl as e };

package/loaders/index3.js

@@ -0,0 +1,135 @@
+/* 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 = options || {},
+    _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;
+}
+
+export { throttle as t };

package/loaders/package.js

@@ -1,3 +1,3 @@
-const version = "9.0.0-next.2";
+const version = "9.0.0-next.21";
 
 export { version as v };