@otto-de/b2b-core-components 1.6.1 → 1.8.0

package/dist/esm/shadow-css-3392baef.js

@@ -0,0 +1,449 @@
+/*
+ Stencil Client Platform v4.7.0 | MIT Licensed | https://stenciljs.com
+ */
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ *
+ * This file is a port of shadowCSS from `webcomponents.js` to TypeScript.
+ * https://github.com/webcomponents/webcomponentsjs/blob/4efecd7e0e/src/ShadowCSS/ShadowCSS.js
+ * https://github.com/angular/angular/blob/master/packages/compiler/src/shadow_css.ts
+ */
+const safeSelector = (selector) => {
+    const placeholders = [];
+    let index = 0;
+    // Replaces attribute selectors with placeholders.
+    // The WS in [attr="va lue"] would otherwise be interpreted as a selector separator.
+    selector = selector.replace(/(\[[^\]]*\])/g, (_, keep) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(keep);
+        index++;
+        return replaceBy;
+    });
+    // Replaces the expression in `:nth-child(2n + 1)` with a placeholder.
+    // WS and "+" would otherwise be interpreted as selector separators.
+    const content = selector.replace(/(:nth-[-\w]+)(\([^)]+\))/g, (_, pseudo, exp) => {
+        const replaceBy = `__ph-${index}__`;
+        placeholders.push(exp);
+        index++;
+        return pseudo + replaceBy;
+    });
+    const ss = {
+        content,
+        placeholders,
+    };
+    return ss;
+};
+const restoreSafeSelector = (placeholders, content) => {
+    return content.replace(/__ph-(\d+)__/g, (_, index) => placeholders[+index]);
+};
+const _polyfillHost = '-shadowcsshost';
+const _polyfillSlotted = '-shadowcssslotted';
+// note: :host-context pre-processed to -shadowcsshostcontext.
+const _polyfillHostContext = '-shadowcsscontext';
+const _parenSuffix = ')(?:\\((' + '(?:\\([^)(]*\\)|[^)(]*)+?' + ')\\))?([^,{]*)';
+const _cssColonHostRe = new RegExp('(' + _polyfillHost + _parenSuffix, 'gim');
+const _cssColonHostContextRe = new RegExp('(' + _polyfillHostContext + _parenSuffix, 'gim');
+const _cssColonSlottedRe = new RegExp('(' + _polyfillSlotted + _parenSuffix, 'gim');
+const _polyfillHostNoCombinator = _polyfillHost + '-no-combinator';
+const _polyfillHostNoCombinatorRe = /-shadowcsshost-no-combinator([^\s]*)/;
+const _shadowDOMSelectorsRe = [/::shadow/g, /::content/g];
+const _selectorReSuffix = '([>\\s~+[.,{:][\\s\\S]*)?$';
+const _polyfillHostRe = /-shadowcsshost/gim;
+/**
+ * Little helper for generating a regex that will match a specified
+ * CSS selector when that selector is _not_ a part of a `@supports` rule.
+ *
+ * The pattern will match the provided `selector` (i.e. ':host', ':host-context', etc.)
+ * when that selector is not a part of a `@supports` selector rule _or_ if the selector
+ * is a part of the rule's declaration.
+ *
+ * For instance, if we create the regex with the selector ':host-context':
+ * - '@supports selector(:host-context())' will return no matches (starts with '@supports')
+ * - '@supports selector(:host-context()) { :host-context() { ... }}' will match the second ':host-context' (part of declaration)
+ * - ':host-context() { ... }' will match ':host-context' (selector is not a '@supports' rule)
+ * - ':host() { ... }' will return no matches (selector doesn't match selector used to create regex)
+ *
+ * @param selector The CSS selector we want to match for replacement
+ * @returns A look-behind regex containing the selector
+ */
+const createSupportsRuleRe = (selector) => new RegExp(`((?<!(^@supports(.*)))|(?<=\{.*))(${selector}\\b)`, 'gim');
+const _colonSlottedRe = createSupportsRuleRe('::slotted');
+const _colonHostRe = createSupportsRuleRe(':host');
+const _colonHostContextRe = createSupportsRuleRe(':host-context');
+const _commentRe = /\/\*\s*[\s\S]*?\*\//g;
+const stripComments = (input) => {
+    return input.replace(_commentRe, '');
+};
+const _commentWithHashRe = /\/\*\s*#\s*source(Mapping)?URL=[\s\S]+?\*\//g;
+const extractCommentsWithHash = (input) => {
+    return input.match(_commentWithHashRe) || [];
+};
+const _ruleRe = /(\s*)([^;\{\}]+?)(\s*)((?:{%BLOCK%}?\s*;?)|(?:\s*;))/g;
+const _curlyRe = /([{}])/g;
+const _selectorPartsRe = /(^.*?[^\\])??((:+)(.*)|$)/;
+const OPEN_CURLY = '{';
+const CLOSE_CURLY = '}';
+const BLOCK_PLACEHOLDER = '%BLOCK%';
+const processRules = (input, ruleCallback) => {
+    const inputWithEscapedBlocks = escapeBlocks(input);
+    let nextBlockIndex = 0;
+    return inputWithEscapedBlocks.escapedString.replace(_ruleRe, (...m) => {
+        const selector = m[2];
+        let content = '';
+        let suffix = m[4];
+        let contentPrefix = '';
+        if (suffix && suffix.startsWith('{' + BLOCK_PLACEHOLDER)) {
+            content = inputWithEscapedBlocks.blocks[nextBlockIndex++];
+            suffix = suffix.substring(BLOCK_PLACEHOLDER.length + 1);
+            contentPrefix = '{';
+        }
+        const cssRule = {
+            selector,
+            content,
+        };
+        const rule = ruleCallback(cssRule);
+        return `${m[1]}${rule.selector}${m[3]}${contentPrefix}${rule.content}${suffix}`;
+    });
+};
+const escapeBlocks = (input) => {
+    const inputParts = input.split(_curlyRe);
+    const resultParts = [];
+    const escapedBlocks = [];
+    let bracketCount = 0;
+    let currentBlockParts = [];
+    for (let partIndex = 0; partIndex < inputParts.length; partIndex++) {
+        const part = inputParts[partIndex];
+        if (part === CLOSE_CURLY) {
+            bracketCount--;
+        }
+        if (bracketCount > 0) {
+            currentBlockParts.push(part);
+        }
+        else {
+            if (currentBlockParts.length > 0) {
+                escapedBlocks.push(currentBlockParts.join(''));
+                resultParts.push(BLOCK_PLACEHOLDER);
+                currentBlockParts = [];
+            }
+            resultParts.push(part);
+        }
+        if (part === OPEN_CURLY) {
+            bracketCount++;
+        }
+    }
+    if (currentBlockParts.length > 0) {
+        escapedBlocks.push(currentBlockParts.join(''));
+        resultParts.push(BLOCK_PLACEHOLDER);
+    }
+    const strEscapedBlocks = {
+        escapedString: resultParts.join(''),
+        blocks: escapedBlocks,
+    };
+    return strEscapedBlocks;
+};
+/**
+ * Replaces certain strings within the CSS with placeholders
+ * that will later be replaced with class selectors appropriate
+ * for the level of encapsulation (shadow or scoped).
+ *
+ * When performing these replacements, we want to ignore selectors that are a
+ * part of an `@supports` rule. Replacing these selectors will result in invalid
+ * CSS that gets passed to autoprefixer/postcss once the placeholders are replaced.
+ * For example, a rule like:
+ *
+ * ```css
+ * @supports selector(:host()) {
+ *   :host {
+ *     color: red;
+ *   }
+ * }
+ * ```
+ *
+ * Should be converted to:
+ *
+ * ```css
+ * @supports selector(:host()) {
+ *   -shadowcsshost {
+ *     color: red;
+ *   }
+ * }
+ * ```
+ *
+ * The order the regex replacements happen in matters since we match
+ * against a whole selector word so we need to match all of `:host-context`
+ * before we try to replace `:host`. Otherwise the pattern for `:host` would match
+ * `:host-context` resulting in something like `:-shadowcsshost-context`.
+ *
+ * @param cssText A CSS string for a component
+ * @returns The modified CSS string
+ */
+const insertPolyfillHostInCssText = (cssText) => {
+    // These replacements use a special syntax with the `$1`. When the replacement
+    // occurs, `$1` maps to the content of the string leading up to the selector
+    // to be replaced.
+    //
+    // Otherwise, we will replace all the preceding content in addition to the
+    // selector because of the lookbehind in the regex.
+    //
+    // e.g. `/*!@___0___*/:host {}` => `/*!@___0___*/--shadowcsshost {}`
+    cssText = cssText
+        .replace(_colonHostContextRe, `$1${_polyfillHostContext}`)
+        .replace(_colonHostRe, `$1${_polyfillHost}`)
+        .replace(_colonSlottedRe, `$1${_polyfillSlotted}`);
+    return cssText;
+};
+const convertColonRule = (cssText, regExp, partReplacer) => {
+    // m[1] = :host(-context), m[2] = contents of (), m[3] rest of rule
+    return cssText.replace(regExp, (...m) => {
+        if (m[2]) {
+            const parts = m[2].split(',');
+            const r = [];
+            for (let i = 0; i < parts.length; i++) {
+                const p = parts[i].trim();
+                if (!p)
+                    break;
+                r.push(partReplacer(_polyfillHostNoCombinator, p, m[3]));
+            }
+            return r.join(',');
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+};
+const colonHostPartReplacer = (host, part, suffix) => {
+    return host + part.replace(_polyfillHost, '') + suffix;
+};
+const convertColonHost = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostRe, colonHostPartReplacer);
+};
+const colonHostContextPartReplacer = (host, part, suffix) => {
+    if (part.indexOf(_polyfillHost) > -1) {
+        return colonHostPartReplacer(host, part, suffix);
+    }
+    else {
+        return host + part + suffix + ', ' + part + ' ' + host + suffix;
+    }
+};
+const convertColonSlotted = (cssText, slotScopeId) => {
+    const slotClass = '.' + slotScopeId + ' > ';
+    const selectors = [];
+    cssText = cssText.replace(_cssColonSlottedRe, (...m) => {
+        if (m[2]) {
+            const compound = m[2].trim();
+            const suffix = m[3];
+            const slottedSelector = slotClass + compound + suffix;
+            let prefixSelector = '';
+            for (let i = m[4] - 1; i >= 0; i--) {
+                const char = m[5][i];
+                if (char === '}' || char === ',') {
+                    break;
+                }
+                prefixSelector = char + prefixSelector;
+            }
+            const orgSelector = prefixSelector + slottedSelector;
+            const addedSelector = `${prefixSelector.trimRight()}${slottedSelector.trim()}`;
+            if (orgSelector.trim() !== addedSelector.trim()) {
+                const updatedSelector = `${addedSelector}, ${orgSelector}`;
+                selectors.push({
+                    orgSelector,
+                    updatedSelector,
+                });
+            }
+            return slottedSelector;
+        }
+        else {
+            return _polyfillHostNoCombinator + m[3];
+        }
+    });
+    return {
+        selectors,
+        cssText,
+    };
+};
+const convertColonHostContext = (cssText) => {
+    return convertColonRule(cssText, _cssColonHostContextRe, colonHostContextPartReplacer);
+};
+const convertShadowDOMSelectors = (cssText) => {
+    return _shadowDOMSelectorsRe.reduce((result, pattern) => result.replace(pattern, ' '), cssText);
+};
+const makeScopeMatcher = (scopeSelector) => {
+    const lre = /\[/g;
+    const rre = /\]/g;
+    scopeSelector = scopeSelector.replace(lre, '\\[').replace(rre, '\\]');
+    return new RegExp('^(' + scopeSelector + ')' + _selectorReSuffix, 'm');
+};
+const selectorNeedsScoping = (selector, scopeSelector) => {
+    const re = makeScopeMatcher(scopeSelector);
+    return !re.test(selector);
+};
+const injectScopingSelector = (selector, scopingSelector) => {
+    return selector.replace(_selectorPartsRe, (_, before = '', _colonGroup, colon = '', after = '') => {
+        return before + scopingSelector + colon + after;
+    });
+};
+const applySimpleSelectorScope = (selector, scopeSelector, hostSelector) => {
+    // In Android browser, the lastIndex is not reset when the regex is used in String.replace()
+    _polyfillHostRe.lastIndex = 0;
+    if (_polyfillHostRe.test(selector)) {
+        const replaceBy = `.${hostSelector}`;
+        return selector
+            .replace(_polyfillHostNoCombinatorRe, (_, selector) => injectScopingSelector(selector, replaceBy))
+            .replace(_polyfillHostRe, replaceBy + ' ');
+    }
+    return scopeSelector + ' ' + selector;
+};
+const applyStrictSelectorScope = (selector, scopeSelector, hostSelector) => {
+    const isRe = /\[is=([^\]]*)\]/g;
+    scopeSelector = scopeSelector.replace(isRe, (_, ...parts) => parts[0]);
+    const className = '.' + scopeSelector;
+    const _scopeSelectorPart = (p) => {
+        let scopedP = p.trim();
+        if (!scopedP) {
+            return '';
+        }
+        if (p.indexOf(_polyfillHostNoCombinator) > -1) {
+            scopedP = applySimpleSelectorScope(p, scopeSelector, hostSelector);
+        }
+        else {
+            // remove :host since it should be unnecessary
+            const t = p.replace(_polyfillHostRe, '');
+            if (t.length > 0) {
+                scopedP = injectScopingSelector(t, className);
+            }
+        }
+        return scopedP;
+    };
+    const safeContent = safeSelector(selector);
+    selector = safeContent.content;
+    let scopedSelector = '';
+    let startIndex = 0;
+    let res;
+    const sep = /( |>|\+|~(?!=))\s*/g;
+    // If a selector appears before :host it should not be shimmed as it
+    // matches on ancestor elements and not on elements in the host's shadow
+    // `:host-context(div)` is transformed to
+    // `-shadowcsshost-no-combinatordiv, div -shadowcsshost-no-combinator`
+    // the `div` is not part of the component in the 2nd selectors and should not be scoped.
+    // Historically `component-tag:host` was matching the component so we also want to preserve
+    // this behavior to avoid breaking legacy apps (it should not match).
+    // The behavior should be:
+    // - `tag:host` -> `tag[h]` (this is to avoid breaking legacy apps, should not match anything)
+    // - `tag :host` -> `tag [h]` (`tag` is not scoped because it's considered part of a
+    //   `:host-context(tag)`)
+    const hasHost = selector.indexOf(_polyfillHostNoCombinator) > -1;
+    // Only scope parts after the first `-shadowcsshost-no-combinator` when it is present
+    let shouldScope = !hasHost;
+    while ((res = sep.exec(selector)) !== null) {
+        const separator = res[1];
+        const part = selector.slice(startIndex, res.index).trim();
+        shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+        const scopedPart = shouldScope ? _scopeSelectorPart(part) : part;
+        scopedSelector += `${scopedPart} ${separator} `;
+        startIndex = sep.lastIndex;
+    }
+    const part = selector.substring(startIndex);
+    shouldScope = shouldScope || part.indexOf(_polyfillHostNoCombinator) > -1;
+    scopedSelector += shouldScope ? _scopeSelectorPart(part) : part;
+    // replace the placeholders with their original values
+    return restoreSafeSelector(safeContent.placeholders, scopedSelector);
+};
+const scopeSelector = (selector, scopeSelectorText, hostSelector, slotSelector) => {
+    return selector
+        .split(',')
+        .map((shallowPart) => {
+        if (slotSelector && shallowPart.indexOf('.' + slotSelector) > -1) {
+            return shallowPart.trim();
+        }
+        if (selectorNeedsScoping(shallowPart, scopeSelectorText)) {
+            return applyStrictSelectorScope(shallowPart, scopeSelectorText, hostSelector).trim();
+        }
+        else {
+            return shallowPart.trim();
+        }
+    })
+        .join(', ');
+};
+const scopeSelectors = (cssText, scopeSelectorText, hostSelector, slotSelector, commentOriginalSelector) => {
+    return processRules(cssText, (rule) => {
+        let selector = rule.selector;
+        let content = rule.content;
+        if (rule.selector[0] !== '@') {
+            selector = scopeSelector(rule.selector, scopeSelectorText, hostSelector, slotSelector);
+        }
+        else if (rule.selector.startsWith('@media') ||
+            rule.selector.startsWith('@supports') ||
+            rule.selector.startsWith('@page') ||
+            rule.selector.startsWith('@document')) {
+            content = scopeSelectors(rule.content, scopeSelectorText, hostSelector, slotSelector);
+        }
+        const cssRule = {
+            selector: selector.replace(/\s{2,}/g, ' ').trim(),
+            content,
+        };
+        return cssRule;
+    });
+};
+const scopeCssText = (cssText, scopeId, hostScopeId, slotScopeId, commentOriginalSelector) => {
+    cssText = insertPolyfillHostInCssText(cssText);
+    cssText = convertColonHost(cssText);
+    cssText = convertColonHostContext(cssText);
+    const slotted = convertColonSlotted(cssText, slotScopeId);
+    cssText = slotted.cssText;
+    cssText = convertShadowDOMSelectors(cssText);
+    if (scopeId) {
+        cssText = scopeSelectors(cssText, scopeId, hostScopeId, slotScopeId);
+    }
+    cssText = cssText.replace(/-shadowcsshost-no-combinator/g, `.${hostScopeId}`);
+    cssText = cssText.replace(/>\s*\*\s+([^{, ]+)/gm, ' $1 ');
+    return {
+        cssText: cssText.trim(),
+        slottedSelectors: slotted.selectors,
+    };
+};
+const scopeCss = (cssText, scopeId, commentOriginalSelector) => {
+    const hostScopeId = scopeId + '-h';
+    const slotScopeId = scopeId + '-s';
+    const commentsWithHash = extractCommentsWithHash(cssText);
+    cssText = stripComments(cssText);
+    const orgSelectors = [];
+    if (commentOriginalSelector) {
+        const processCommentedSelector = (rule) => {
+            const placeholder = `/*!@___${orgSelectors.length}___*/`;
+            const comment = `/*!@${rule.selector}*/`;
+            orgSelectors.push({ placeholder, comment });
+            rule.selector = placeholder + rule.selector;
+            return rule;
+        };
+        cssText = processRules(cssText, (rule) => {
+            if (rule.selector[0] !== '@') {
+                return processCommentedSelector(rule);
+            }
+            else if (rule.selector.startsWith('@media') ||
+                rule.selector.startsWith('@supports') ||
+                rule.selector.startsWith('@page') ||
+                rule.selector.startsWith('@document')) {
+                rule.content = processRules(rule.content, processCommentedSelector);
+                return rule;
+            }
+            return rule;
+        });
+    }
+    const scoped = scopeCssText(cssText, scopeId, hostScopeId, slotScopeId);
+    cssText = [scoped.cssText, ...commentsWithHash].join('\n');
+    if (commentOriginalSelector) {
+        orgSelectors.forEach(({ placeholder, comment }) => {
+            cssText = cssText.replace(placeholder, comment);
+        });
+    }
+    scoped.slottedSelectors.forEach((slottedSelector) => {
+        cssText = cssText.replace(slottedSelector.orgSelector, slottedSelector.updatedSelector);
+    });
+    return cssText;
+};
+
+export { scopeCss };

package/dist/esm/table.types-7607e721.js

@@ -0,0 +1,40 @@
+const TableSizes = {
+  EQUAL: 'equal',
+  EXPAND: 'expand',
+};
+const TableRowgroupTypes = {
+  HEADER: 'header',
+  BODY: 'body',
+  FOOTER: 'footer',
+};
+const ContentAlignment = {
+  LEFT: 'left',
+  RIGHT: 'right',
+  CENTER: 'center',
+};
+const SortIconAlignment = {
+  LEFT: 'left',
+  RIGHT: 'right',
+  CENTER: 'center',
+};
+const TableSortDirections = {
+  NOT: 'not-sorted',
+  ASC: 'ascending',
+  DESC: 'descending',
+};
+const TableAccordionRowTypes = {
+  PARENT: 'parent',
+  CHILD: 'child',
+  HEADER: 'header',
+};
+const TableCheckboxTypes = {
+  HEADER: 'header',
+  ROW: 'row',
+};
+const TableColourOptions = {
+  DEFAULT: 'default',
+  SELECTED: 'selected',
+  GROUP: 'group',
+};
+
+export { ContentAlignment as C, SortIconAlignment as S, TableSizes as T, TableSortDirections as a, TableAccordionRowTypes as b, TableColourOptions as c, TableRowgroupTypes as d };

package/dist/esm/{table.types-dd829d83.js → table.types-c4d9046e.js}

@@ -12,6 +12,11 @@ const ContentAlignment = {
   RIGHT: 'right',
   CENTER: 'center',
 };
+const SortIconAlignment = {
+  LEFT: 'left',
+  RIGHT: 'right',
+  CENTER: 'center',
+};
 const TableSortDirections = {
   NOT: 'not-sorted',
   ASC: 'ascending',
@@ -28,4 +33,4 @@ const TableColourOptions = {
   GROUP: 'group',
 };
 
-export { ContentAlignment as C, TableSizes as T, TableSortDirections as a, TableAccordionRowTypes as b, TableColourOptions as c, TableRowgroupTypes as d };
+export { ContentAlignment as C, SortIconAlignment as S, TableSizes as T, TableSortDirections as a, TableAccordionRowTypes as b, TableColourOptions as c, TableRowgroupTypes as d };

package/dist/esm/wizard.types-f1a7c73a.js

@@ -0,0 +1,8 @@
+const WizardStatus = {
+  DEFAULT: 'default',
+  COMPLETED: 'completed',
+  PENDING: 'pending',
+  DISABLED: 'disabled',
+};
+
+export { WizardStatus as W };

package/{loader → dist/loader}/cdn.js

@@ -1,3 +1,3 @@
 
-module.exports = require('../dist/cjs/loader.cjs.js');
+module.exports = require('../cjs/loader.cjs.js');
 module.exports.applyPolyfills = function() { return Promise.resolve() };

package/{loader → dist/loader}/index.cjs.js

@@ -1,3 +1,3 @@
 
-module.exports = require('../dist/cjs/loader.cjs.js');
+module.exports = require('../cjs/loader.cjs.js');
 module.exports.applyPolyfills = function() { return Promise.resolve() };

package/{loader → dist/loader}/index.d.ts

@@ -1,4 +1,4 @@
-export * from '../dist/types/components';
+export * from '../types/components';
 export interface CustomElementsDefineOptions {
   exclude?: string[];
   resourcesUrl?: string;
@@ -8,7 +8,7 @@ export interface CustomElementsDefineOptions {
   ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
   rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
 }
-export declare function defineCustomElements(win?: Window, opts?: CustomElementsDefineOptions): Promise<void>;
+export declare function defineCustomElements(win?: Window, opts?: CustomElementsDefineOptions): void;
 export declare function applyPolyfills(): Promise<void>;
 
 /**

package/dist/loader/index.es2017.js

@@ -0,0 +1,3 @@
+
+export * from '../esm/polyfills/index.js';
+export * from '../esm/loader.js';

package/{loader → dist/loader}/index.js

@@ -1,4 +1,4 @@
 
 (function(){if("undefined"!==typeof window&&void 0!==window.Reflect&&void 0!==window.customElements){var a=HTMLElement;window.HTMLElement=function(){return Reflect.construct(a,[],this.constructor)};HTMLElement.prototype=a.prototype;HTMLElement.prototype.constructor=HTMLElement;Object.setPrototypeOf(HTMLElement,a)}})();
-export * from '../dist/esm/polyfills/index.js';
-export * from '../dist/esm/loader.js';
+export * from '../esm/polyfills/index.js';
+export * from '../esm/loader.js';

package/dist/scripts/stencil/generate-storybook-args.js

@@ -4,7 +4,7 @@ used in Storybook (ArgTypes). Storybook wasn't inferring correctly all the infor
 from the component, so we automate this with this script.
 */
 // @ts-ignore
-import fs from 'fs';
+import fs from "fs";
 const hasOptions = prop => prop.values.length > 1;
 const isBoolean = prop => prop.type === 'boolean';
 const setDefaultValue = (propData, prop) => {

package/dist/scripts/stencil/generate-vue-web-types.js

@@ -3,7 +3,7 @@ This script is used by Stencil to output from component docs to the WebTypes
 format used by IntelliJ IDEs, to help with code completion and syntax.
 For more information you can see https://github.com/JetBrains/web-types
 */
-import fs from 'fs';
+import fs from "fs";
 const formatValues = propValues => propValues
   .split('|')
   .map(s => s.trim())

package/dist/types/components/breadcrumb/breadcrumb-item.d.ts

@@ -0,0 +1,15 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { BreadCrumbChangeEventDetail } from '../../utils/interfaces/interaction.interface';
+export declare class BreadCrumbItemComponent {
+  /** If defined, an anchor tag will be rendered instead of a span, opening the specified link in the same context when clicked. */
+  href: string;
+  /** The value associated with the current page. It is required, must be unique and can be a page title, an id or something similar. */
+  value: any;
+  /** If the item is currently selected. If true, it will not emit an event when clicked and does not have a hover state.*/
+  active: boolean;
+  /** @internal Emits whenever a breadcrumb item is clicked and no href is specified */
+  b2bChange: EventEmitter<BreadCrumbChangeEventDetail>;
+  private onClick;
+  private onKeyDown;
+  render(): any;
+}

package/dist/types/components/breadcrumb/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { BreadCrumbChangeEventDetail } from '../../utils/interfaces/interaction.interface';
+export declare class B2bBreadCrumbComponent {
+  host: HTMLB2bBreadcrumbElement;
+  /** Emits the value of the currently selected item whenever an item is selected. */
+  b2bSelected: EventEmitter<BreadCrumbChangeEventDetail>;
+  onSelectedChange(event: any): void;
+  private getBreadcrumbItems;
+  private updateActiveItem;
+  render(): any;
+}

package/dist/types/components/breadcrumb/breadcrumb.stories.d.ts

@@ -0,0 +1,4 @@
+import { Meta } from '@storybook/web-components';
+export declare const story010Default: any;
+declare const _default: Meta;
+export default _default;

package/dist/types/components/button/button.stories.d.ts

@@ -1,12 +1,14 @@
-import { Meta } from '@storybook/web-components';
-export declare const story010Secondary: any;
-export declare const story020Primary: any;
-export declare const story030Loading: any;
-export declare const story040IconStart: any;
-export declare const story050IconEnd: any;
-export declare const story055IconStartPali: any;
-export declare const story060IconSearch: any;
-export declare const story070Disabled: any;
-export declare const story080Anchor: any;
-declare const _default: Meta;
-export default _default;
+import { Meta, StoryObj } from '@storybook/web-components';
+declare const meta: Meta;
+export default meta;
+type Story = StoryObj;
+export declare const Primary: Story;
+export declare const Secondary: Story;
+export declare const Loading: Story;
+export declare const IconStart: Story;
+export declare const IconEnd: Story;
+export declare const PaliIcon: Story;
+export declare const IconOnly: Story;
+export declare const Disabled: Story;
+export declare const Anchor: Story;
+export declare const DisabledAnchor: Story;

package/dist/types/components/chip/chip.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { ChipComponentEventDetail } from '../../utils/interfaces/form.interface';
+export declare class B2bChipComponent {
+  host: HTMLB2bChipComponentElement;
+  /** The text content of the chip. It is required. */
+  label: string;
+  /** Whether the chip is disabled. */
+  disabled: boolean;
+  /** Whether or not the chip component has a close button. Per default it is true. */
+  hasCloseButton: boolean;
+  /** It is only used when the chip component participates in a group */
+  value?: any;
+  /** This event will be triggered when the chip element is closed */
+  b2bClose: EventEmitter<ChipComponentEventDetail>;
+  private onClick;
+  private clearIcon;
+  render(): any;
+}

package/dist/types/components/chip/chip.stories.d.ts

@@ -0,0 +1,7 @@
+import { Meta } from '@storybook/web-components';
+export declare const story010Default: any;
+export declare const story020Disabled: any;
+export declare const story030WithoutButton: any;
+export declare const story040WithTruncatedText: any;
+declare const _default: Meta;
+export default _default;