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

package/dist/collection/components/post-header/post-header.js

@@ -0,0 +1,267 @@
+import { h, Host, } from "@stencil/core";
+import { throttle } from "throttle-debounce";
+import { version } from "../../../../package";
+import { slideDown, slideUp } from "../../animations/slide";
+import { getFocusableChildren } from "../../utils/get-focusable-children";
+/**
+ * @slot post-logo - Should be used together with the `<post-logo>` component.
+ * @slot meta-navigation - Holds an `<ul>` with meta navigation links.
+ * @slot post-togglebutton - Holds the mobile menu toggler.
+ * @slot post-language-switch - Should be used with the `<post-language-switch>` component.
+ * @slot title - Holds the application title.
+ * @slot default - Custom controls or content, right aligned in the local header.
+ * @slot post-mainnavigation - Has a default slot because it's only meant to be used in the `<post-header>`.
+ */
+export class PostHeader {
+    constructor() {
+        this.device = null;
+        this.mobileMenuExtended = false;
+    }
+    firstFocusableEl;
+    lastFocusableEl;
+    scrollParent = null;
+    mobileMenu;
+    mobileMenuAnimation;
+    throttledScroll = () => this.handleScrollEvent();
+    throttledResize = throttle(50, () => this.handleResize());
+    componentWillRender() {
+        this.scrollParent = this.getScrollParent(this.host);
+        this.scrollParent.addEventListener('scroll', this.throttledScroll, { passive: true });
+        window.addEventListener('resize', this.throttledResize, { passive: true });
+        this.handleResize();
+        this.handleScrollEvent();
+        this.getFocusableElements();
+    }
+    componentDidLoad() {
+        this.updateLocalHeaderHeight();
+    }
+    // Clean up possible side effects when post-header is disconnected
+    disconnectedCallback() {
+        this.mobileMenuExtended = false;
+        document.body.style.overflow = '';
+        this.host.removeEventListener('keydown', e => {
+            this.keyboardHandler(e);
+        });
+    }
+    host;
+    frozeBody(isMobileMenuExtended) {
+        document.body.style.overflow = isMobileMenuExtended ? 'hidden' : '';
+        if (isMobileMenuExtended) {
+            this.host.addEventListener('keydown', e => {
+                this.keyboardHandler(e);
+            });
+        }
+        else {
+            this.host.removeEventListener('keydown', e => {
+                this.keyboardHandler(e);
+            });
+        }
+    }
+    /**
+     * An event emitted when the device has changed
+     */
+    postUpdateDevice;
+    /**
+     * Toggles the mobile navigation.
+     */
+    async toggleMobileMenu() {
+        if (this.device === 'desktop')
+            return;
+        this.mobileMenuAnimation = this.mobileMenuExtended
+            ? slideUp(this.mobileMenu)
+            : slideDown(this.mobileMenu);
+        // Update the state of the toggle button
+        const menuButton = this.host.querySelector('post-togglebutton');
+        menuButton.toggled = !this.mobileMenuExtended;
+        // Toggle menu visibility before it slides down and after it slides back up
+        if (this.mobileMenuExtended)
+            await this.mobileMenuAnimation.finished;
+        this.mobileMenuExtended = !this.mobileMenuExtended;
+        if (!this.mobileMenuExtended)
+            await this.mobileMenuAnimation.finished;
+    }
+    // Get all the focusable elements in the post-header mobile menu
+    getFocusableElements() {
+        // Get elements in the correct order (different as the DOM order)
+        const focusableEls = [
+            ...Array.from(this.host.querySelectorAll('.list-inline:not([slot="meta-navigation"]) > li')),
+            ...Array.from(this.host.querySelectorAll('nav > post-list > div > post-list-item, post-mainnavigation > .back-button, post-megadropdown-trigger')),
+            ...Array.from(this.host.querySelectorAll('.list-inline[slot="meta-navigation"] > li, post-language-option')),
+        ];
+        // Add the main toggle menu button to the list of focusable children
+        const focusableChildren = [
+            this.host.querySelector('post-togglebutton'),
+            ...focusableEls.flatMap(el => Array.from(getFocusableChildren(el))),
+        ];
+        this.firstFocusableEl = focusableChildren[0];
+        this.lastFocusableEl = focusableChildren[focusableChildren.length - 1];
+    }
+    keyboardHandler(e) {
+        if (e.key === 'Tab' && this.mobileMenuExtended) {
+            if (e.shiftKey && document.activeElement === this.firstFocusableEl) {
+                // If back tab (Tab + Shift) and first element is focused, focus goes to the last element of the megadropdown
+                e.preventDefault();
+                this.lastFocusableEl.focus();
+            }
+            else if (!e.shiftKey && document.activeElement === this.lastFocusableEl) {
+                // If Tab and last element is focused, focus goes back to the first element of the megadropdown
+                e.preventDefault();
+                this.firstFocusableEl.focus();
+            }
+        }
+    }
+    handleScrollEvent() {
+        // Credits: "https://github.com/qeremy/so/blob/master/so.dom.js#L426"
+        const st = Math.max(0, this.scrollParent instanceof Document
+            ? this.scrollParent.documentElement.scrollTop
+            : this.scrollParent.scrollTop);
+        this.host.style.setProperty('--header-scroll-top', `${st}px`);
+    }
+    getScrollParent(node) {
+        let currentParent = node.parentElement;
+        while (currentParent) {
+            if (currentParent.nodeName === 'BODY') {
+                return document;
+            }
+            if (this.isScrollable(currentParent)) {
+                return currentParent;
+            }
+            currentParent = currentParent.parentElement;
+        }
+        return document;
+    }
+    isScrollable(node) {
+        if (!(node instanceof HTMLElement || node instanceof SVGElement)) {
+            return false;
+        }
+        const style = getComputedStyle(node);
+        return ['overflow', 'overflow-x', 'overflow-y'].some(propertyName => {
+            const value = style.getPropertyValue(propertyName);
+            return value === 'auto' || value === 'scroll';
+        });
+    }
+    updateLocalHeaderHeight() {
+        requestAnimationFrame(() => {
+            const mhh = this.host.shadowRoot.querySelector('.local-header')?.clientHeight || 0;
+            this.host.style.setProperty('--local-header-height', `${mhh}px`);
+        });
+    }
+    handleResize() {
+        const previousDevice = this.device;
+        let newDevice;
+        const width = window?.innerWidth;
+        if (width >= 1024) {
+            newDevice = 'desktop';
+        }
+        else if (width >= 600) {
+            newDevice = 'tablet';
+        }
+        else {
+            newDevice = 'mobile';
+        }
+        // Close any open mobile menu
+        if (newDevice === 'desktop' && this.mobileMenuExtended) {
+            this.toggleMobileMenu();
+            this.mobileMenuAnimation.finish(); // no animation
+        }
+        this.updateLocalHeaderHeight();
+        // Apply only on change for doing work only when necessary
+        if (newDevice !== previousDevice) {
+            this.device = newDevice;
+            this.postUpdateDevice.emit(this.device);
+            window.requestAnimationFrame(() => {
+                this.switchLanguageSwitchMode();
+            });
+        }
+    }
+    switchLanguageSwitchMode() {
+        const variant = this.device === 'desktop' ? 'menu' : 'list';
+        Array.from(this.host.querySelectorAll('post-language-switch')).forEach(languageSwitch => {
+            languageSwitch?.setAttribute('variant', variant);
+        });
+    }
+    renderNavigation() {
+        const navigationClasses = ['navigation'];
+        if (this.mobileMenuExtended) {
+            navigationClasses.push('extended');
+        }
+        return (h("div", { ref: el => (this.mobileMenu = el), class: navigationClasses.join(' ') }, h("slot", { name: "post-mainnavigation" }), (this.device === 'mobile' || this.device === 'tablet') && (h("div", { class: "navigation-footer" }, h("slot", { name: "meta-navigation" }), h("slot", { name: "post-language-switch" })))));
+    }
+    render() {
+        return (h(Host, { key: '45452d2c2f6ac9a067ce71330ea898a797040cca', version: version }, h("div", { key: 'c50478141de45d0a718b18c0edc416eb9c832fde', class: "global-header" }, h("div", { key: 'a2ddc2de9a94fb3b16928fe9c1ac3b3ae61ff9bf', class: "global-sub" }, h("div", { key: '30083683ff7683202118471473f2a0ed98a1c920', class: "logo" }, h("slot", { key: '028bd4a8f03a228378b09a80dce8654d52c30e5c', name: "post-logo" }))), h("div", { key: '853bcf2e6c8a95d88f62795cef8d8e58c8996811', class: "global-sub" }, this.device === 'desktop' && h("slot", { key: '40e3027a4e4358b7a614558ed7e1f59fa65ed312', name: "meta-navigation" }), h("slot", { key: '31c141cc45aa12441557d9b817630328df3d3778', name: "global-controls" }), this.device === 'desktop' && h("slot", { key: 'afe4b2c3123a89c1a4390578c22e89dfff7be655', name: "post-language-switch" }), h("div", { key: 'aea74d0c7f25288afa18b5aeb3e557216d695ec3', onClick: () => this.toggleMobileMenu(), class: "mobile-toggle" }, h("slot", { key: '1efed8b7c823ef49b89120ed2e23f151c64b9c0e', name: "post-togglebutton" })))), h("div", { key: 'e09df2136d01c0516d0166f505055615cf1d70d3', class: 'local-header ' + (this.mobileMenuExtended ? 'local-header-mobile-extended' : '') }, h("slot", { key: '491f9bbcb2743519f544b24ae6f00405be85e589', name: "title" }), h("div", { key: 'e85c0a76597832a6966e989111b4508579fb9c4d', class: "local-sub" }, h("slot", { key: 'f2d504ea6a3d7592a15551e6be8cb0c1ba220fbc', name: "local-controls" }), h("slot", { key: 'e0dd0f9c12e0c6bf5d5d66cb29139af59f7c0b4d' })), this.device === 'desktop' && this.renderNavigation()), this.device !== 'desktop' && this.renderNavigation()));
+    }
+    static get is() { return "post-header"; }
+    static get encapsulation() { return "shadow"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["./post-header.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["post-header.css"]
+        };
+    }
+    static get states() {
+        return {
+            "device": {},
+            "mobileMenuExtended": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "postUpdateDevice",
+                "name": "postUpdateDevice",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "An event emitted when the device has changed"
+                },
+                "complexType": {
+                    "original": "DEVICE_SIZE",
+                    "resolved": "\"desktop\" | \"mobile\" | \"tablet\"",
+                    "references": {
+                        "DEVICE_SIZE": {
+                            "location": "local",
+                            "path": "/home/runner/work/design-system/design-system/packages/components/src/components/post-header/post-header.tsx",
+                            "id": "src/components/post-header/post-header.tsx::DEVICE_SIZE"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "toggleMobileMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "HTMLPostTogglebuttonElement": {
+                            "location": "global",
+                            "id": "global::HTMLPostTogglebuttonElement"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Toggles the mobile navigation.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "host"; }
+    static get watchers() {
+        return [{
+                "propName": "mobileMenuExtended",
+                "methodName": "frozeBody"
+            }];
+    }
+}

package/dist/collection/components/post-icon/post-icon.js

@@ -1,7 +1,7 @@
 import { Host, h } from "@stencil/core";
 import { checkNonEmpty, checkType, checkEmptyOrType, checkEmptyOrOneOf } from "../../utils/index";
 import { version } from "../../../../package";
-const CDN_URL = 'https://unpkg.com/@swisspost/design-system-icons/public/post-icons';
+const CDN_URL = 'https://unpkg.com/@swisspost/design-system-icons/public/post-icons/';
 const ANIMATION_NAMES = [
     'cylon',
     'cylon-vertical',
@@ -16,8 +16,6 @@ const ANIMATION_KEYS = [...ANIMATION_NAMES];
  */
 export class PostIcon {
     constructor() {
-        this.svgStyles = undefined;
-        this.svgOutput = undefined;
         this.animation = null;
         this.base = null;
         this.flipH = false;
@@ -26,30 +24,93 @@ export class PostIcon {
         this.rotate = null;
         this.scale = null;
     }
+    isSSR = typeof window === 'undefined';
+    host;
     validateAnimation(newValue = this.animation) {
         if (newValue !== undefined)
-            checkEmptyOrOneOf(newValue, ANIMATION_KEYS, `The post-icon "animation" prop requires one of the following values: ${ANIMATION_KEYS.join(', ')}.`);
+            checkEmptyOrOneOf(this, 'animation', ANIMATION_KEYS);
     }
-    validateBase(newValue = this.base) {
-        checkEmptyOrType(newValue, 'string', 'The post-icon "base" prop should be a string.');
+    validateBase() {
+        checkEmptyOrType(this, 'base', 'string');
     }
-    validateFlipH(newValue = this.flipH) {
-        checkEmptyOrType(newValue, 'boolean', 'The post-icon "flipH" prop should be a boolean.');
+    validateFlipH() {
+        checkEmptyOrType(this, 'flipH', 'boolean');
     }
-    validateFlipV(newValue = this.flipV) {
-        checkEmptyOrType(newValue, 'boolean', 'The post-icon "flipV" prop should be a boolean.');
+    validateFlipV() {
+        checkEmptyOrType(this, 'flipV', 'boolean');
     }
-    validateName(newValue = this.name) {
-        checkNonEmpty(newValue, 'The post-icon "name" prop is required!.');
-        checkType(newValue, 'string', 'The post-icon "name" prop should be a string.');
+    validateName() {
+        checkNonEmpty(this, 'name');
+        checkType(this, 'name', 'string');
     }
-    validateRotate(newValue = this.rotate) {
-        checkEmptyOrType(newValue, 'number', 'The post-icon "rotate" prop should be a number.');
+    validateRotate() {
+        checkEmptyOrType(this, 'rotate', 'number');
     }
-    validateScale(newValue = this.scale) {
-        checkEmptyOrType(newValue, 'number', 'The post-icon "scale" prop should be a number.');
+    validateScale() {
+        checkEmptyOrType(this, 'scale', 'number');
     }
-    componentWillLoad() {
+    // Construct the icon url from different possible sources
+    getUrl() {
+        let url;
+        const file = `${this.name}.svg`;
+        // the first definition object which defines a domain, will be used to set the domain of the file url
+        // the first definition object which defines a slug, will be used to set the slug of the file url
+        const urlDefinitions = [this.getUrlDefinition(this.base, 'both')];
+        if (!this.isSSR) {
+            urlDefinitions.push(this.getUrlDefinition(document.head
+                .querySelector('meta[name="design-system-settings"][data-post-icon-base]')
+                ?.getAttribute('data-post-icon-base'), 'relative'));
+            urlDefinitions.push(this.getUrlDefinition(document.querySelector('base[href]')?.getAttribute('href'), 'both'));
+        }
+        // in case no definition defines a domain, a relative url is used to load the icon
+        const origin = urlDefinitions.find(d => d.definesDomain)?.url?.origin;
+        // in case no definition defines a slug either, the cdn url is used as a fallback
+        const slug = urlDefinitions.find(d => d.definesSlug)?.url?.pathname;
+        if (origin && slug) {
+            url = `${origin}${slug}${file}`;
+        }
+        else if (!origin && slug) {
+            url = `${slug}${file}`;
+        }
+        else {
+            url = `${CDN_URL}${file}`;
+        }
+        return url;
+    }
+    getUrlDefinition(url, allow) {
+        return {
+            url: this.getUrlObject(url),
+            definesDomain: allow !== 'relative' ? this.definesDomain(url) : false,
+            definesSlug: allow !== 'absolute' ? this.definesSlug(url) : false,
+        };
+    }
+    getUrlObject(url) {
+        if (url) {
+            url = url?.endsWith('/') ? url : `${url}/`;
+            return new URL(url, 'https://url.base');
+        }
+        else {
+            return null;
+        }
+    }
+    definesDomain(url) {
+        return url ? /^https?:\/\//.test(url) : false;
+    }
+    definesSlug(url) {
+        return Boolean(/^\/.+/.test(this.getUrlObject(url)?.pathname));
+    }
+    getStyles() {
+        const url = this.getUrl();
+        return Object.entries({
+            '-webkit-mask-image': `url(${url})`,
+            'mask-image': `url('${url}')`,
+            'transform': (this.scale && !isNaN(Number(this.scale)) ? 'scale(' + this.scale + ')' : '') +
+                (this.rotate && !isNaN(Number(this.rotate)) ? ' rotate(' + this.rotate + 'deg)' : ''),
+        })
+            .filter(([_key, value]) => value !== null)
+            .reduce((styles, [key, value]) => Object.assign(styles, { [key]: value }), {});
+    }
+    componentDidLoad() {
         this.validateBase();
         this.validateName();
         this.validateFlipH();
@@ -58,30 +119,8 @@ export class PostIcon {
         this.validateRotate();
         this.validateAnimation();
     }
-    componentWillRender() {
-        this.setPath();
-    }
-    setPath() {
-        var _a, _b, _c, _d;
-        // Construct icon path from different possible sources
-        const metaBase = (_b = (_a = document.head
-            .querySelector('meta[name="design-system-settings"][data-post-icon-base]')) === null || _a === void 0 ? void 0 : _a.getAttribute('data-post-icon-base')) !== null && _b !== void 0 ? _b : null;
-        const fileBase = `${(_d = (_c = this.base) !== null && _c !== void 0 ? _c : metaBase) !== null && _d !== void 0 ? _d : CDN_URL}/`.replace(/\/\/$/, '/');
-        const fileName = `${this.name}.svg`;
-        const filePath = `${fileBase}${fileName}`;
-        this.path = new URL(filePath, window.location.origin).toString();
-    }
     render() {
-        // create inline styles for some properties
-        const svgStyles = Object.entries({
-            '-webkit-mask-image': `url('${this.path}')`,
-            'mask-image': `url('${this.path}')`,
-            'transform': (this.scale && !isNaN(Number(this.scale)) ? 'scale(' + this.scale + ')' : '') +
-                (this.rotate && !isNaN(Number(this.rotate)) ? ' rotate(' + this.rotate + 'deg)' : ''),
-        })
-            .filter(([_key, value]) => value !== null)
-            .reduce((styles, [key, value]) => Object.assign(styles, { [key]: value }), {});
-        return (h(Host, { key: '95fa0f7a09d3430bb5d621e01b57188742920eb4', "data-version": version }, h("span", { key: 'c824e3705dc83665bb6f7649381654e6d1e07dfb', style: svgStyles })));
+        return (h(Host, { key: 'c80aaf693f730902c4ae57ca78360eee5dedf624', "data-version": version }, h("span", { key: '7e01e1cf7e4fec380e8f054d3cc8fa5404c7a829', style: this.getStyles() })));
     }
     static get is() { return "post-icon"; }
     static get encapsulation() { return "shadow"; }
@@ -229,12 +268,6 @@ export class PostIcon {
             }
         };
     }
-    static get states() {
-        return {
-            "svgStyles": {},
-            "svgOutput": {}
-        };
-    }
     static get elementRef() { return "host"; }
     static get watchers() {
         return [{

package/dist/collection/components/post-language-option/post-language-option.css

@@ -0,0 +1,3 @@
+/*!
+ * Copyright 2021 by Swiss Post, Information Technology
+ */post-language-option{display:inline-block}post-language-option button{padding:0;overflow:visible;border:0;background:none;color:var(--post-scheme-color-interactive-button-secondary-enabled-fg);font:inherit;-webkit-user-select:none;user-select:none;appearance:button}@media(forced-colors: active),(-ms-high-contrast: active),(-ms-high-contrast: white-on-black){post-language-option button{background-color:ButtonFace !important}post-language-option button:hover{background-color:Highlight !important}}post-language-option a{color:inherit;text-decoration:none}post-language-option :is(a,button){cursor:pointer;display:flex;align-items:center;justify-content:center;width:100%;height:100%;border-radius:2px;text-transform:uppercase}post-language-option :is(a,button){outline-offset:var(--post-device-spacing-padding-2) !important;outline:var(--post-scheme-color-interactive-focus-stroke) none var(--post-device-border-width-focus) !important}post-language-option :is(a,button):is(:focus-visible,:has(:focus-visible),.pretend-focus){outline-style:var(--post-core-border-style-solid) !important}@media(forced-colors: active),(-ms-high-contrast: active),(-ms-high-contrast: white-on-black){post-language-option :is(a,button):is(:focus-visible,:has(:focus-visible),.pretend-focus){outline-color:Highlight !important}}@supports not selector(:has(:focus-visible)){post-language-option :is(a,button):is(:focus-visible,:focus-within,.pretend-focus){outline-style:var(--post-core-border-style-solid) !important}@media(forced-colors: active),(-ms-high-contrast: active),(-ms-high-contrast: white-on-black){post-language-option :is(a,button):is(:focus-visible,:focus-within,.pretend-focus){outline-color:Highlight !important}}}post-language-option:where([variant=list]) :is(a,button){padding-inline:0;width:40px;height:40px;border-radius:2px}post-language-option:where([variant=list]) :is(a,button):hover{color:#504f4b}post-language-option:where([variant=list]):not([active=false]) :is(a,button){background-color:#050400 !important;color:#fff;pointer-events:none}post-language-option:where([variant=list]):not([active=false]) :hover{color:#fff}post-language-option:where([variant=menu]){width:100%}post-language-option:where([variant=menu]):not([active=false]){display:none}post-language-option:where([variant=menu]) :is(a,button){padding-block:13px;padding-inline:24px;box-sizing:border-box;position:relative;width:100%}post-language-option:where([variant=menu]) :is(a,button):hover{color:#fff;background-color:#504f4b}

package/dist/collection/components/post-language-option/post-language-option.js

@@ -0,0 +1,224 @@
+import { Host, h, } from "@stencil/core";
+import { checkEmptyOrType, checkType } from "../../utils/index";
+import { version } from "../../../../package";
+/**
+ * @slot default - Slot for placing the content inside the anchor or button.
+ */
+export class PostLanguageOption {
+    constructor() {
+        this.code = undefined;
+        this.active = undefined;
+        this.variant = undefined;
+        this.name = undefined;
+        this.url = undefined;
+    }
+    host;
+    validateCode() {
+        checkType(this, 'code', 'string');
+    }
+    validateActiveProp() {
+        checkEmptyOrType(this, 'active', 'boolean');
+    }
+    validateName() {
+        checkEmptyOrType(this, 'name', 'string');
+    }
+    validateUrl() {
+        checkEmptyOrType(this, 'url', 'string');
+    }
+    componentDidLoad() {
+        this.validateCode();
+        this.validateActiveProp();
+        this.validateName();
+        this.validateUrl();
+        if (!this.name && this.isNameRequired()) {
+            throw new Error('The "name" property of the post-language-option component is required when the full language name is not displayed.');
+        }
+    }
+    /**
+     * An event emitted when the language option is clicked. The payload is the ISO 639 code of the language.
+     */
+    postChange;
+    /**
+     * Selects the language option programmatically.
+     */
+    async select() {
+        this.active = true;
+        this.emitChange();
+    }
+    emitChange() {
+        this.postChange.emit(this.code);
+    }
+    isNameRequired() {
+        return this.host.textContent.toLowerCase() === this.code.toLowerCase();
+    }
+    render() {
+        const lang = this.code.toLowerCase();
+        const emitOnKeyDown = (e) => {
+            if (e.key === 'Enter' || e.key === ' ') {
+                this.emitChange();
+            }
+        };
+        return (h(Host, { key: 'f987cfc18bb86866781e0668516e86f89be6241b', "data-version": version, role: this.variant ? `${this.variant}item` : null }, this.url ? (h("a", { "aria-current": this.active ? 'page' : undefined, "aria-label": this.name, href: this.url, hrefLang: lang, lang: lang, onClick: () => this.emitChange(), onKeyDown: emitOnKeyDown }, h("slot", null))) : (h("button", { "aria-current": this.active ? 'true' : undefined, "aria-label": this.name, lang: lang, onClick: () => this.emitChange(), onKeyDown: emitOnKeyDown }, h("slot", null)))));
+    }
+    static get is() { return "post-language-option"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["post-language-option.scss"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["post-language-option.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "code": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": true,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The ISO 639 language code, formatted according to [RFC 5646 (also known as BCP 47)](https://datatracker.ietf.org/doc/html/rfc5646). For example, \"de\"."
+                },
+                "attribute": "code",
+                "reflect": false
+            },
+            "active": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "If set to `true`, the language option is considered the current language for the page."
+                },
+                "attribute": "active",
+                "reflect": true
+            },
+            "variant": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "SwitchVariant | null",
+                    "resolved": "\"list\" | \"menu\"",
+                    "references": {
+                        "SwitchVariant": {
+                            "location": "import",
+                            "path": "../post-language-switch/switch-variants",
+                            "id": "src/components/post-language-switch/switch-variants.ts::SwitchVariant"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "To communicate the variant prop from the parent (post-language-switch) component to the child (post-language-option) component. See parent docs for a description about the property itself."
+                },
+                "attribute": "variant",
+                "reflect": false
+            },
+            "name": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The full name of the language. For example, \"Deutsch\"."
+                },
+                "attribute": "name",
+                "reflect": false
+            },
+            "url": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The URL used for the href attribute of the internal anchor.\nThis field is optional; if not provided, a button will be used internally instead of an anchor."
+                },
+                "attribute": "url",
+                "reflect": false
+            }
+        };
+    }
+    static get events() {
+        return [{
+                "method": "postChange",
+                "name": "postChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": "An event emitted when the language option is clicked. The payload is the ISO 639 code of the language."
+                },
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "select": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Selects the language option programmatically.",
+                    "tags": []
+                }
+            }
+        };
+    }
+    static get elementRef() { return "host"; }
+    static get watchers() {
+        return [{
+                "propName": "code",
+                "methodName": "validateCode"
+            }, {
+                "propName": "active",
+                "methodName": "validateActiveProp"
+            }, {
+                "propName": "name",
+                "methodName": "validateName"
+            }, {
+                "propName": "url",
+                "methodName": "validateUrl"
+            }];
+    }
+}