@cupra/ui-kit 0.0.2-placeholder → 0.2.0-canary.0

package/dist/mixins/FormAssociatedMixin.d.ts

@@ -0,0 +1,4 @@
+import type { LitElement } from 'lit';
+type Constructor<T = {}> = new (...args: any[]) => T;
+export declare const FormAssociatedMixin: <T extends Constructor<LitElement>>(superClass: T) => T;
+export {};

package/dist/mixins/ViewportMixin.d.ts

@@ -0,0 +1,8 @@
+import type { ReactiveElement } from 'lit';
+type Constructor<T = {}> = new (...args: any[]) => T;
+export interface ViewportInterface {
+    viewport: string;
+}
+type ViewportMixinType<T extends Constructor<ReactiveElement>> = Constructor<ViewportInterface> & T;
+export declare const ViewportMixin: <T extends Constructor<ReactiveElement>>(superClass: T) => ViewportMixinType<T>;
+export {};

package/dist/mixins/inputStatesMixin.d.ts

@@ -0,0 +1,16 @@
+import type { ReactiveElement } from 'lit';
+type Constructor<T = {}> = new (...args: any[]) => T;
+export interface InputStatesInterface {
+    inputStates: {
+        currentValue: string;
+        focus: boolean;
+        focusVisible: boolean;
+        invalid: boolean;
+        filled: boolean;
+        disabled: boolean;
+    };
+    nativeInput: HTMLInputElement | HTMLTextAreaElement | undefined;
+}
+type InputStatesMixin<T extends Constructor<ReactiveElement>> = Constructor<InputStatesInterface> & T;
+export declare const inputStatesMixin: <T extends Constructor<ReactiveElement>>(superClass: T) => InputStatesMixin<T>;
+export {};

package/dist/styles/fonts-config.d.ts

@@ -0,0 +1,11 @@
+interface FontsConfig {
+    [key: string]: {
+        fonts: Array<{
+            name: string;
+            weight: string;
+            file: string;
+        }>;
+    };
+}
+export declare const fontsConfig: FontsConfig;
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,8 @@
+export interface CommonAttrs {
+    [key: string]: any;
+}
+declare global {
+    interface Window {
+        DS_THEME: string;
+    }
+}

package/dist/utils/IconsManager.d.ts

@@ -0,0 +1,14 @@
+import type { Icons } from '../components/ds-icon/Icons.type.ts';
+declare class IconsManager {
+    private static instance;
+    private icons;
+    private theme;
+    private constructor();
+    handleChangeTheme: (theme: string) => void;
+    static getInstance(): IconsManager;
+    private getCachedIcon;
+    fetchIcon: (iconName: Icons, requestInit?: RequestInit) => Promise<string>;
+    private loadIcon;
+}
+export declare const iconsManager: IconsManager;
+export {};

package/dist/utils/PubSub.d.ts

@@ -0,0 +1,18 @@
+type Subscribers = {
+    [key: string]: any;
+};
+type LastPublishedData = {
+    [key: string]: any;
+};
+export declare class PubSub {
+    private static instance;
+    subscribers: Subscribers;
+    lastPublishedData: LastPublishedData;
+    constructor();
+    static getInstance(): PubSub;
+    subscribe(event: string, callback: Function): any;
+    unsubscribe(event: string, callback: Function): void;
+    publish(event: string, data: unknown): void;
+}
+export declare const pubSub: PubSub;
+export {};

package/dist/utils/StylesRegistry/StylesRegistry.d.ts

@@ -0,0 +1,14 @@
+import { Theme } from '../../components/ds-theme-provider/themeContext.ts';
+declare class StylesRegistry {
+    private static instance;
+    private stylePromises;
+    getStyles: ({ componentName, theme, }: {
+        componentName?: string;
+        theme: Theme;
+    }) => Promise<string | void>;
+    private fetchStyle;
+    private getCachedStyleSheetPromise;
+    static getInstance(): StylesRegistry;
+}
+export declare const stylesRegistry: StylesRegistry;
+export {};

package/dist/utils/StylesRegistry/StylesRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/arrayConverter.d.ts

@@ -0,0 +1,4 @@
+export declare const arrayConverter: {
+    fromAttribute(value: string): unknown[];
+    toAttribute(value: unknown[]): string;
+};

package/dist/utils/booleanConverter.d.ts

@@ -0,0 +1 @@
+export declare const booleanConverter: (value: unknown) => boolean;

package/dist/utils/breakpoints.d.ts

@@ -0,0 +1,4 @@
+type Viewports = 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl';
+export declare const breakpoints: Record<Viewports, number>;
+export declare const viewportQueries: Record<Viewports, string>;
+export {};

package/dist/utils/breakpoints.js

@@ -0,0 +1,19 @@
+const i = {
+  xs: 0,
+  s: 480,
+  m: 768,
+  l: 1024,
+  xl: 1440,
+  xxl: 1920
+}, x = {
+  xs: `@media(min-width: ${i.xs}px)`,
+  s: `@media(min-width: ${i.s}px)`,
+  m: `@media(min-width: ${i.m}px)`,
+  l: `@media(min-width: ${i.l}px)`,
+  xl: `@media(min-width: ${i.xl}px)`,
+  xxl: `@media(min-width: ${i.xxl}px)`
+};
+export {
+  i as breakpoints,
+  x as viewportQueries
+};

package/dist/utils/componentFactory.d.ts

@@ -0,0 +1,16 @@
+import type { DsButtonAttrs } from '../components/ds-button/ds-button.types.ts';
+import type { DsIconButtonAttrs } from '../components/ds-icon-button/ds-icon-button.types.ts';
+import type { DsIconAttrs } from '../components/ds-icon/ds-icon.types.ts';
+import type { DsLoaderSpinnerAttrs } from '../components/ds-loader-spinner/ds-loader-spinner.types.ts';
+import { DsToastMessageAttrs } from '../components/ds-toast-message/ds-toast-message.types.ts';
+type GetAttributes<T> = (props?: T) => any;
+export type ComponentFactory = {
+    createIcon: GetAttributes<DsIconAttrs>;
+    createButton: GetAttributes<DsButtonAttrs>;
+    createIconButton: GetAttributes<DsIconButtonAttrs>;
+    createLoaderSpinner: GetAttributes<DsLoaderSpinnerAttrs>;
+    createToastMessage: GetAttributes<DsToastMessageAttrs>;
+};
+export declare const standardFactory: ComponentFactory;
+export declare const reactFactory: ComponentFactory;
+export {};

package/dist/utils/cssQueries.d.ts

@@ -0,0 +1,8 @@
+export declare const cssQueries: {
+    xs: import("lit").CSSResult;
+    s: import("lit").CSSResult;
+    m: import("lit").CSSResult;
+    l: import("lit").CSSResult;
+    xl: import("lit").CSSResult;
+    xxl: import("lit").CSSResult;
+};

package/dist/utils/cssWithTokens.d.ts

@@ -0,0 +1,2 @@
+import { type CSSResult } from 'lit';
+export declare function cssWithTokens(strings: TemplateStringsArray, ...values: unknown[]): CSSResult;

package/dist/utils/debounce.d.ts

@@ -0,0 +1,6 @@
+type DebounceReturn = (params?: any) => void | Function;
+export declare function debounce({ func, milliseconds }: {
+    func: Function;
+    milliseconds?: number;
+}): DebounceReturn;
+export {};

package/dist/utils/debounce.js

@@ -0,0 +1,11 @@
+function u({ func: t, milliseconds: n = 100 }) {
+  let e;
+  return function(o) {
+    clearTimeout(e), e = setTimeout(() => {
+      t(o);
+    }, n);
+  };
+}
+export {
+  u as debounce
+};

package/dist/utils/debounce.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/defineCustomElement.d.ts

@@ -0,0 +1,8 @@
+import type { LitElement } from 'lit';
+type DefineWCWithSuffixProps = {
+    name: string;
+    suffix?: string;
+    WCClass: new () => LitElement;
+};
+export declare function defineCustomElement({ name, suffix, WCClass }: DefineWCWithSuffixProps): void;
+export {};

package/dist/utils/formatNumber/formatNumber.d.ts

@@ -0,0 +1,243 @@
+type Locales = {
+    Cy: 'az-AZ' | 'sr-SP' | 'uz-UZ';
+    Lt: 'az-AZ' | 'sr-SP' | 'uz-UZ';
+    aa: '';
+    ab: '';
+    ae: '';
+    af: 'ZA';
+    ak: '';
+    am: '';
+    an: '';
+    ar: 'AE' | 'BH' | 'DZ' | 'EG' | 'IQ' | 'JO' | 'KW' | 'LB' | 'LY' | 'MA' | 'OM' | 'QA' | 'SA' | 'SY' | 'TN' | 'YE';
+    as: '';
+    av: '';
+    ay: '';
+    az: '';
+    ba: '';
+    be: 'BY';
+    bg: 'BG';
+    bh: '';
+    bi: '';
+    bm: '';
+    bn: '';
+    bo: '';
+    br: '';
+    bs: '';
+    ca: 'ES';
+    ce: '';
+    ch: '';
+    co: '';
+    cr: '';
+    cs: 'CZ';
+    cu: '';
+    cv: '';
+    cy: '';
+    da: 'DK';
+    de: 'AT' | 'CH' | 'DE' | 'LI' | 'LU';
+    dv: 'MV';
+    dz: '';
+    ee: '';
+    el: 'GR';
+    en: 'AU' | 'BZ' | 'CA' | 'CB' | 'GB' | 'IE' | 'JM' | 'NZ' | 'PH' | 'TT' | 'US' | 'ZA' | 'ZW';
+    eo: '';
+    es: 'AR' | 'BO' | 'CL' | 'CO' | 'CR' | 'DO' | 'EC' | 'ES' | 'GT' | 'HN' | 'MX' | 'NI' | 'PA' | 'PE' | 'PR' | 'PY' | 'SV' | 'UY' | 'VE';
+    et: 'EE';
+    eu: 'ES';
+    fa: 'IR';
+    ff: '';
+    fi: 'FI';
+    fj: '';
+    fo: 'FO';
+    fr: 'BE' | 'CA' | 'CH' | 'FR' | 'LU' | 'MC';
+    fy: '';
+    ga: '';
+    gd: '';
+    gl: 'ES';
+    gn: '';
+    gu: 'IN';
+    gv: '';
+    ha: '';
+    he: 'IL';
+    hi: 'IN';
+    ho: '';
+    hr: 'HR';
+    ht: '';
+    hu: 'HU';
+    hy: 'AM';
+    hz: '';
+    ia: '';
+    id: 'ID';
+    ie: '';
+    ig: '';
+    ii: '';
+    ik: '';
+    io: '';
+    is: 'IS';
+    it: 'CH' | 'IT';
+    iu: '';
+    ja: 'JP';
+    jv: '';
+    ka: 'GE';
+    kg: '';
+    ki: '';
+    kj: '';
+    kk: 'KZ';
+    kl: '';
+    km: '';
+    kn: 'IN';
+    ko: 'KR';
+    kr: '';
+    ks: '';
+    ku: '';
+    kv: '';
+    kw: '';
+    ky: 'KZ';
+    la: '';
+    lb: '';
+    lg: '';
+    li: '';
+    ln: '';
+    lo: '';
+    lt: 'LT';
+    lu: '';
+    lv: 'LV';
+    mg: '';
+    mh: '';
+    mi: '';
+    mk: 'MK';
+    ml: '';
+    mn: 'MN';
+    mr: 'IN';
+    ms: 'BN' | 'MY';
+    mt: '';
+    my: '';
+    na: '';
+    nb: 'NO';
+    nd: '';
+    ne: '';
+    ng: '';
+    nl: 'BE' | 'NL';
+    nn: 'NO';
+    no: '';
+    nr: '';
+    nv: '';
+    ny: '';
+    oc: '';
+    oj: '';
+    om: '';
+    or: '';
+    os: '';
+    pa: 'IN';
+    pi: '';
+    pl: 'PL';
+    ps: '';
+    pt: 'BR' | 'PT';
+    qu: '';
+    rm: '';
+    rn: '';
+    ro: 'RO';
+    ru: 'RU';
+    rw: '';
+    sa: 'IN';
+    sc: '';
+    sd: '';
+    se: '';
+    sg: '';
+    si: '';
+    sk: 'SK';
+    sl: 'SI';
+    sm: '';
+    sn: '';
+    so: '';
+    sq: 'AL';
+    sr: '';
+    ss: '';
+    st: '';
+    su: '';
+    sv: 'FI' | 'SE';
+    sw: 'KE';
+    ta: 'IN';
+    te: 'IN';
+    tg: '';
+    th: 'TH';
+    ti: '';
+    tk: '';
+    tl: '';
+    tn: '';
+    to: '';
+    tr: 'TR';
+    ts: '';
+    tt: 'RU';
+    tw: '';
+    ty: '';
+    ug: '';
+    uk: 'UA';
+    ur: 'PK';
+    uz: '';
+    ve: '';
+    vi: 'VN';
+    vo: '';
+    wa: '';
+    wo: '';
+    xh: '';
+    yi: '';
+    yo: '';
+    za: '';
+    zh: 'CHS' | 'CHT' | 'CN' | 'HK' | 'MO' | 'SG' | 'TW';
+    zu: '';
+};
+export type Integer1To20 = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
+/**
+ Limit fraction digits to 20 instead of 100 as per the documentation because:
+ 1. Some environments (e.g., tests) throw errors with more than 20 decimals.
+ 2. JS floats have a precision limit less than 20 decimals, making higher values impractical.
+**/
+export type Integer0To20 = 0 | Integer1To20;
+export type Integer1To21 = Integer1To20 | 21;
+export type Locale = {
+    [K in keyof Locales]: Locales[K] extends '' ? K : `${K}-${Locales[K]}`;
+}[keyof Locales];
+export type Currency = {
+    style: 'currency';
+    currency: string;
+    unit?: never;
+};
+export type Decimal = {
+    style: 'decimal';
+    currency?: never;
+    unit?: never;
+};
+export type Percent = {
+    style: 'percent';
+    currency?: never;
+    unit?: never;
+};
+export type Unit = {
+    style: 'unit';
+    currency?: never;
+    unit: string;
+};
+export type NoUnit = {
+    style?: never;
+    currency?: never;
+    unit?: never;
+};
+type UnitStyle = Currency | Decimal | Percent | Unit | NoUnit;
+export type FormatNumberProps = UnitStyle & {
+    value: number;
+    locale?: Locale;
+    localeMatcher?: 'lookup' | 'best fit';
+    minimumIntegerDigits?: Integer1To21;
+    minimumFractionDigits?: Integer0To20;
+    maximumFractionDigits?: Integer0To20;
+    thousandSeparator?: string;
+    fractionSeparator?: string;
+    useGrouping?: 'auto' | 'always' | 'min2' | boolean;
+};
+export type FormatedNumber = {
+    formattedValue: string;
+    unitSymbol?: string;
+    unitSymbolPosition?: 'left' | 'right';
+};
+export declare function formatNumber({ value, locale, style, unit, currency, localeMatcher, minimumIntegerDigits, minimumFractionDigits, maximumFractionDigits, thousandSeparator, fractionSeparator, useGrouping, }: FormatNumberProps): FormatedNumber;
+export {};

package/dist/utils/formatNumber/formatNumber.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/htmlWithTokens.d.ts

@@ -0,0 +1,2 @@
+import { type HTMLTemplateResult } from 'lit';
+export declare function htmlWithTokens(strings: TemplateStringsArray, ...values: unknown[]): HTMLTemplateResult;

package/dist/utils/objectConverter.d.ts

@@ -0,0 +1 @@
+export declare const objectConverter: (value: unknown) => any;

package/dist/utils/validateMaxLength.d.ts

@@ -0,0 +1 @@
+export declare function validateMaxLength(maxLength: unknown): boolean;

package/dist/utils/validateMaxLength.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist-react/components/base/DsUiElement.d.ts

@@ -0,0 +1,16 @@
+import { type Theme } from '../ds-theme-provider/themeContext';
+import { type CSSResult, LitElement, type PropertyValues } from 'lit';
+export type ThemesStyles = {
+    [K in Theme]?: CSSResult | CSSResult[];
+};
+export declare class DsUiElement extends LitElement {
+    protected contextTheme?: Theme;
+    protected pubSubTheme: Theme;
+    protected theme: Theme;
+    static themesStyles?: ThemesStyles;
+    constructor();
+    private handleChangeTheme;
+    connectedCallback(): void;
+    updated(changed: PropertyValues): void;
+    private applyTheme;
+}

package/dist-react/components/base/UiKitElement.d.ts

@@ -0,0 +1,20 @@
+import { type Theme } from '../ds-theme-provider/themeContext';
+import { ComponentFactory } from '../../utils/componentFactory.ts';
+import { LitElement, PropertyValues } from 'lit';
+export declare class UiKitElement extends LitElement {
+    protected componentFactory: ComponentFactory;
+    protected contextTheme?: Theme;
+    protected pubSubTheme: Theme;
+    static componentName?: string;
+    private appliedConstructables?;
+    private appliedStyleTags?;
+    constructor();
+    protected get theme(): Theme | undefined;
+    private handleChangeTheme;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues): void;
+    protected getComponentNames(): string[];
+    private supportsAdoptedSheets;
+    private applyThemeStyles;
+}

package/dist-react/components/base/ds-base-input/ds-base-input.d.ts

@@ -0,0 +1,40 @@
+import { DsUiElement, type ThemesStyles } from '../DsUiElement.ts';
+import { type TemplateResult } from 'lit';
+import type { DsBaseInputAttrs } from './ds-base-input.types.ts';
+declare const DsBaseInput_base: typeof DsUiElement;
+export declare abstract class DsBaseInput extends DsBaseInput_base {
+    initialValue: DsBaseInputAttrs['initial-value'];
+    label: DsBaseInputAttrs['label'];
+    helperText: DsBaseInputAttrs['helper-text'];
+    errorText: DsBaseInputAttrs['error-text'];
+    disabled: DsBaseInputAttrs['disabled'];
+    success: DsBaseInputAttrs['success'];
+    mode: DsBaseInputAttrs['mode'];
+    size: DsBaseInputAttrs['size'];
+    protected _value: string;
+    protected focused: boolean;
+    protected inputField: HTMLInputElement;
+    protected firstUpdated(): void;
+    protected get value(): string;
+    protected set value(newValue: string);
+    static styles: import("lit").CSSResult[];
+    static themesStyles: ThemesStyles;
+    protected handleFocus: () => void;
+    protected handleBlur: () => void;
+    protected get classes(): {
+        [x: string]: boolean;
+        container: boolean;
+        focused: boolean;
+        error: boolean;
+        success: boolean;
+        disabled: boolean;
+    };
+    protected abstract handleInput: (event: Event) => void;
+    protected abstract labelTemplate: TemplateResult | symbol;
+    protected abstract inputTemplate: TemplateResult | symbol;
+    protected abstract iconTemplate: TemplateResult | symbol;
+    protected abstract dropdownTemplate: TemplateResult | symbol;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    render(): TemplateResult<1>;
+}
+export {};

package/dist-react/components/base/ds-base-input/ds-base-input.types.d.ts

@@ -0,0 +1,11 @@
+import type { CommonAttrs } from '../../../types/types';
+export interface DsBaseInputAttrs extends CommonAttrs {
+    'initial-value'?: string;
+    label?: string;
+    'helper-text'?: string;
+    'error-text'?: string;
+    disabled?: boolean;
+    success?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'large' | 'small';
+}

package/dist-react/components/base/ds-base-input/styles/common.styles.d.ts

@@ -0,0 +1,2 @@
+export declare const commonStyles: import("lit").CSSResult;
+export declare const inputStyles: import("lit").CSSResult;

package/dist-react/components/base/ds-base-input/styles/cupra.styles.d.ts

@@ -0,0 +1 @@
+export declare const cupraStyles: import("lit").CSSResult[];

package/dist-react/components/base/ds-base-progress-bar/ds-base-progress-bar.d.ts

@@ -0,0 +1,15 @@
+import { DsUiElement, type ThemesStyles } from '../DsUiElement.ts';
+import type { DsBaseProgressBarAttrs } from './ds-base-progress-bar.types.ts';
+export declare class DsBaseProgressBar extends DsUiElement {
+    show: DsBaseProgressBarAttrs['show'];
+    mode: DsBaseProgressBarAttrs['mode'];
+    size: DsBaseProgressBarAttrs['size'];
+    static styles: import("lit").CSSResult[];
+    static themesStyles: ThemesStyles;
+    protected get classes(): {
+        [x: string]: boolean;
+        track: boolean;
+    };
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected get barTemplate(): import("lit").TemplateResult<1>;
+}

package/dist-react/components/base/ds-base-progress-bar/ds-base-progress-bar.types.d.ts

@@ -0,0 +1,6 @@
+import type { CommonAttrs } from '../../../types/types';
+export interface DsBaseProgressBarAttrs extends CommonAttrs {
+    show?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'large' | 'small';
+}

package/dist-react/components/base/ds-base-progress-bar/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;

package/dist-react/components/base/ds-base-progress-bar/styles/cupra-diagonal.styles.d.ts

@@ -0,0 +1 @@
+export declare const cupraDiagonalStyles: import("lit").CSSResult[];

package/dist-react/components/base/ds-base-progress-bar/styles/cupra.styles.d.ts

@@ -0,0 +1 @@
+export declare const cupraStyles: import("lit").CSSResult[];

package/dist-react/components/base/ds-base-progress-bar/styles/seat.styles.d.ts

@@ -0,0 +1 @@
+export declare const seatStyles: import("lit").CSSResult[];

package/dist-react/components/ds-accordion/ds-accordion.d.ts

@@ -0,0 +1,29 @@
+import { UiKitElement } from '../base/UiKitElement.ts';
+import type { DsAccordionAttrs } from '../ds-accordion/ds-accordion.types';
+import { type PropertyValues } from 'lit';
+export declare class DsAccordion extends UiKitElement {
+    static styles: import("lit").CSSResult[];
+    maxHeight: DsAccordionAttrs['max-height'];
+    open: DsAccordionAttrs['open'];
+    mode: DsAccordionAttrs['mode'];
+    size: DsAccordionAttrs['size'];
+    disabled: DsAccordionAttrs['disabled'];
+    _open: boolean;
+    firstUpdated(changedProps: PropertyValues): Promise<void>;
+    protected get containerClasses(): {
+        [x: string]: boolean;
+        container: boolean;
+        disabled: boolean;
+        open: boolean;
+    };
+    protected get dividerClasses(): {
+        [x: string]: boolean;
+        divider: boolean;
+    };
+    protected get openIconTemplate(): any;
+    protected get closeIconTemplate(): any;
+    protected get styleTokens(): import("lit").HTMLTemplateResult;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected handleToggle(event: ToggleEvent): void;
+    render(): import("lit").TemplateResult<1>;
+}

package/dist-react/components/ds-accordion/ds-accordion.types.d.ts

@@ -0,0 +1,8 @@
+import type { CommonAttrs } from '../../types/types';
+export interface DsAccordionAttrs extends CommonAttrs {
+    'max-height'?: number;
+    open?: boolean;
+    mode?: 'dark' | 'light';
+    size?: 'medium' | 'small' | (string & {});
+    disabled?: boolean;
+}

package/dist-react/components/ds-accordion/styles/common.styles.d.ts

@@ -0,0 +1 @@
+export declare const commonStyles: import("lit").CSSResult;