@uzum-tech/ui 1.12.0 → 1.12.1

package/es/_internal/close/src/Close.d.ts

@@ -41,9 +41,9 @@ declare const _default: import("vue").DefineComponent<{
     absolute: BooleanConstructor;
 }>>, {
     disabled: boolean;
-    round: boolean;
     absolute: boolean;
-    isButtonTag: boolean;
+    round: boolean;
     focusable: boolean;
+    isButtonTag: boolean;
 }, {}>;
 export default _default;

package/es/_internal/loading/src/Loading.d.ts

@@ -61,9 +61,9 @@ declare const _default: import("vue").DefineComponent<{
         default: number;
     };
 }>>, {
+    show: boolean;
     strokeWidth: number;
     stroke: string;
-    show: boolean;
     scale: number;
     radius: number;
 }, {}>;

package/es/_internal/safe-top-scrollbar/src/SafeTopScrollbar.d.ts

@@ -338,10 +338,10 @@ declare const SafeTopScrollbar: import("vue").DefineComponent<{
         railColor: string;
     }, any>>>;
 }>>, {
+    readonly trigger: "none" | "hover";
+    readonly xScrollable: boolean;
     readonly duration: number;
     readonly scrollable: boolean;
-    readonly xScrollable: boolean;
-    readonly trigger: "none" | "hover";
     readonly useUnifiedContainer: boolean;
     readonly triggerDisplayManually: boolean;
     readonly internalHoistYRail: boolean;

package/es/_internal/scrollbar/src/Scrollbar.d.ts

@@ -326,10 +326,10 @@ declare const Scrollbar: import("vue").DefineComponent<{
         railColor: string;
     }, any>>>;
 }>>, {
+    readonly trigger: "none" | "hover";
+    readonly xScrollable: boolean;
     readonly duration: number;
     readonly scrollable: boolean;
-    readonly xScrollable: boolean;
-    readonly trigger: "none" | "hover";
     readonly useUnifiedContainer: boolean;
     readonly triggerDisplayManually: boolean;
     readonly internalHoistYRail: boolean;

package/es/_internal/select-menu/src/SelectMenu.d.ts

@@ -672,17 +672,17 @@ declare const _default: import("vue").DefineComponent<{
     value: Value | null;
     loading: boolean;
     inlineThemeDisabled: boolean;
+    resetMenuOnOptionsChange: boolean;
     size: Size;
-    focusable: boolean;
     show: boolean;
-    scrollable: boolean;
+    focusable: boolean;
     multiple: boolean;
-    account: boolean;
-    showCheckmark: boolean;
-    labelField: string;
-    autoPending: boolean;
     virtualScroll: boolean;
     valueField: string;
-    resetMenuOnOptionsChange: boolean;
+    labelField: string;
+    showCheckmark: boolean;
+    account: boolean;
+    scrollable: boolean;
+    autoPending: boolean;
 }, {}>;
 export default _default;

package/es/_internal/selection/src/Selection.d.ts

@@ -1177,25 +1177,25 @@ declare const _default: import("vue").DefineComponent<{
     loading: boolean;
     bordered: boolean | undefined;
     inlineThemeDisabled: boolean;
+    clearable: boolean;
     size: SelectSize;
-    active: boolean;
     round: boolean;
-    pattern: string;
-    autofocus: boolean;
-    filled: boolean;
+    loadingSkeleton: boolean;
+    secondary: boolean;
+    showArrow: boolean;
     multiple: boolean;
-    account: boolean;
-    labelField: string;
+    filterable: boolean;
     valueField: string;
-    showArrow: boolean;
-    secondary: boolean;
+    labelField: string;
+    filled: boolean;
+    ignoreComposition: boolean;
+    counter: boolean;
+    account: boolean;
+    autofocus: boolean;
+    pattern: string;
+    active: boolean;
     selectedOption: SelectBaseOption<string | number, string | ((option: SelectBaseOption<string | number, string | any>, selected: boolean) => VNodeChild)> | null;
     selectedOptions: SelectBaseOption<string | number, string | ((option: SelectBaseOption<string | number, string | any>, selected: boolean) => VNodeChild)>[] | null;
-    filterable: boolean;
-    clearable: boolean;
-    loadingSkeleton: boolean;
     focused: boolean;
-    ignoreComposition: boolean;
-    counter: boolean;
 }, {}>;
 export default _default;

package/es/_internal/skeleton/src/Skeleton.d.ts

@@ -146,8 +146,8 @@ declare const _default: import("vue").DefineComponent<{
     }, any>>>;
 }>>, {
     readonly repeat: number;
-    readonly round: boolean;
     readonly circle: boolean;
+    readonly round: boolean;
     readonly text: boolean;
     readonly animated: boolean;
     readonly sharp: boolean;

package/es/_internal/typography/index.d.ts

@@ -1,2 +1,3 @@
 export { default as InternalUText, internalTextProps } from './src/text';
 export type { InternalTextProps } from './src/text';
+export type { TypographyVariant, TypographyVariantOptions, TypographyVariantWeightsOptions } from './src/variants';

package/es/_internal/typography/src/text.d.ts

@@ -1,5 +1,5 @@
 import { type PropType, ExtractPublicPropTypes } from 'vue';
-import { TypographyVariant } from './variants';
+import { TypographyVariant, TypographyVariantOptions, TypographyVariantWeightsOptions } from './variants';
 export declare const internalTextProps: {
     readonly variant: {
         readonly type: PropType<TypographyVariant>;
@@ -17,6 +17,18 @@ export declare const internalTextProps: {
         readonly type: PropType<"default" | "success" | "info" | "warning" | "error">;
         readonly default: "default";
     };
+    readonly color: {
+        readonly type: PropType<string>;
+        readonly default: undefined;
+    };
+    readonly variantOptions: {
+        readonly type: PropType<TypographyVariantOptions>;
+        readonly default: () => {};
+    };
+    readonly variantWeightsOptions: {
+        readonly type: PropType<TypographyVariantWeightsOptions>;
+        readonly default: () => {};
+    };
     readonly strong: BooleanConstructor;
     readonly italic: BooleanConstructor;
     readonly underline: BooleanConstructor;
@@ -94,6 +106,18 @@ declare const _default: import("vue").DefineComponent<{
         readonly type: PropType<"default" | "success" | "info" | "warning" | "error">;
         readonly default: "default";
     };
+    readonly color: {
+        readonly type: PropType<string>;
+        readonly default: undefined;
+    };
+    readonly variantOptions: {
+        readonly type: PropType<TypographyVariantOptions>;
+        readonly default: () => {};
+    };
+    readonly variantWeightsOptions: {
+        readonly type: PropType<TypographyVariantWeightsOptions>;
+        readonly default: () => {};
+    };
     readonly strong: BooleanConstructor;
     readonly italic: BooleanConstructor;
     readonly underline: BooleanConstructor;
@@ -175,6 +199,18 @@ declare const _default: import("vue").DefineComponent<{
         readonly type: PropType<"default" | "success" | "info" | "warning" | "error">;
         readonly default: "default";
     };
+    readonly color: {
+        readonly type: PropType<string>;
+        readonly default: undefined;
+    };
+    readonly variantOptions: {
+        readonly type: PropType<TypographyVariantOptions>;
+        readonly default: () => {};
+    };
+    readonly variantWeightsOptions: {
+        readonly type: PropType<TypographyVariantWeightsOptions>;
+        readonly default: () => {};
+    };
     readonly strong: BooleanConstructor;
     readonly italic: BooleanConstructor;
     readonly underline: BooleanConstructor;
@@ -234,13 +270,16 @@ declare const _default: import("vue").DefineComponent<{
         codeBorder: string;
     }, any>>>;
 }>>, {
-    readonly type: "default" | "info" | "success" | "warning" | "error";
+    readonly type: "default" | "info" | "warning" | "error" | "success";
     readonly tag: keyof HTMLElementTagNameMap;
+    readonly color: string;
     readonly strong: boolean;
     readonly text: string;
+    readonly variant: TypographyVariant;
     readonly italic: boolean;
     readonly underline: boolean;
     readonly strikethrough: boolean;
-    readonly variant: TypographyVariant;
+    readonly variantOptions: TypographyVariantOptions;
+    readonly variantWeightsOptions: TypographyVariantWeightsOptions;
 }, {}>;
 export default _default;

package/es/_internal/typography/src/text.js

@@ -1,5 +1,5 @@
 import { h, defineComponent, computed } from 'vue';
-import { typographyLight } from '../styles';
+import typographyLight from '../styles/light';
 import style from './styles/text.cssr';
 import { getVariantCssVars, getVariantTag } from './variants';
 import { useTheme, useConfig, useThemeClass } from '../../../_mixins';
@@ -16,6 +16,15 @@ export const internalTextProps = Object.assign(Object.assign({}, useTheme.props)
     }, type: {
         type: String,
         default: 'default'
+    }, color: {
+        type: String,
+        default: undefined
+    }, variantOptions: {
+        type: Object,
+        default: () => ({})
+    }, variantWeightsOptions: {
+        type: Object,
+        default: () => ({})
     }, strong: Boolean, italic: Boolean, underline: Boolean, strikethrough: Boolean });
 export default defineComponent({
     name: 'InternalUText',
@@ -24,6 +33,7 @@ export default defineComponent({
         const { mergedClsPrefixRef, inlineThemeDisabled } = useConfig(props);
         const themeRef = useTheme('Typography', '-text', style, typographyLight, props, mergedClsPrefixRef);
         const cssVarsRef = computed(() => {
+            var _a;
             const { variant } = props;
             const textColorKey = props.type === 'default'
                 ? 'textColor'
@@ -32,7 +42,7 @@ export default defineComponent({
             const baseVars = {
                 '--u-bezier': cubicBezierEaseInOut,
                 '--u-a-text-color': aTextColor,
-                '--u-text-color': textColor,
+                '--u-text-color': (_a = props.color) !== null && _a !== void 0 ? _a : textColor,
                 '--u-font-weight-strong': fontWeightStrong,
                 '--u-font-famliy-mono': fontFamilyMono,
                 '--u-code-border-radius': codeBorderRadius,
@@ -44,12 +54,15 @@ export default defineComponent({
                 '--u-margin': margin,
                 '--u-prefix-color': blockquotePrefixColor
             };
-            return getVariantCssVars(variant, baseVars, fontFamilyWixMadeforDisplay);
+            return getVariantCssVars(variant, baseVars, fontFamilyWixMadeforDisplay, props.variantOptions, props.variantWeightsOptions);
         });
         const themeClassHandle = inlineThemeDisabled
             ? useThemeClass('text', computed(() => `${(props === null || props === void 0 ? void 0 : props.variant) || ''}${(props === null || props === void 0 ? void 0 : props.tag) || ''}`), cssVarsRef, props)
             : undefined;
-        const tagToRender = props.tag || (props.variant && getVariantTag(props.variant)) || 'span';
+        const tagToRender = props.tag ||
+            (props.variant &&
+                getVariantTag(props.variant, props.variantOptions, props.variantWeightsOptions)) ||
+            'span';
         return {
             mergedClsPrefix: mergedClsPrefixRef,
             tagToRender,

package/es/_internal/typography/src/variants.d.ts

@@ -1,4 +1,11 @@
-export type TypographyVariant = 'display-l' | 'display-s' | 'heading-l-semi-bold' | 'heading-l-bold' | 'heading-m-semi-bold' | 'heading-m-bold' | 'heading-s-semi-bold' | 'heading-s-bold' | 'title-l-medium' | 'title-l-semi-bold' | 'title-l-bold' | 'title-m-medium' | 'title-m-semi-bold' | 'title-m-bold' | 'title-s-medium' | 'title-s-semi-bold' | 'title-s-bold' | 'body-l-medium' | 'body-l-semi-bold' | 'body-l-bold' | 'body-m-medium' | 'body-m-semi-bold' | 'body-m-bold' | 'body-s-medium' | 'body-s-semi-bold' | 'body-s-bold';
+export interface TypographyVariantBase {
+    fontSize: string;
+    lineHeight: string;
+    letterSpacing: string;
+    tag: keyof HTMLElementTagNameMap;
+}
+export type TypographyVariantOptions = Record<PropertyKey, Record<PropertyKey, TypographyVariantBase>>;
+export type TypographyVariantWeightsOptions = Record<PropertyKey, readonly string[]>;
 export interface TypographyVariantConfig {
     fontFamily: string;
     fontSize: string;
@@ -8,6 +15,100 @@ export interface TypographyVariantConfig {
     letterSpacing: string;
     tag: keyof HTMLElementTagNameMap;
 }
-export declare function getVariantCssVars(variant: TypographyVariant | undefined, baseVars: Record<string, string>, fontFamilyVariant: string): Record<string, string>;
-export declare function getVariantTag(variant: TypographyVariant): keyof HTMLElementTagNameMap;
-export declare const variantToCssVars: Record<TypographyVariant, TypographyVariantConfig>;
+export declare const defaultVariantOptions: {
+    readonly display: {
+        readonly l: {
+            readonly fontSize: "42px";
+            readonly lineHeight: "48px";
+            readonly letterSpacing: "-0.014em";
+            readonly tag: "h1";
+        };
+        readonly s: {
+            readonly fontSize: "36px";
+            readonly lineHeight: "44px";
+            readonly letterSpacing: "-0.013em";
+            readonly tag: "h1";
+        };
+    };
+    readonly heading: {
+        readonly l: {
+            readonly fontSize: "32px";
+            readonly lineHeight: "40px";
+            readonly letterSpacing: "-0.01em";
+            readonly tag: "h2";
+        };
+        readonly m: {
+            readonly fontSize: "28px";
+            readonly lineHeight: "36px";
+            readonly letterSpacing: "-0.009em";
+            readonly tag: "h2";
+        };
+        readonly s: {
+            readonly fontSize: "24px";
+            readonly lineHeight: "30px";
+            readonly letterSpacing: "-0.01em";
+            readonly tag: "h2";
+        };
+    };
+    readonly title: {
+        readonly l: {
+            readonly fontSize: "22px";
+            readonly lineHeight: "32px";
+            readonly letterSpacing: "-0.01em";
+            readonly tag: "h3";
+        };
+        readonly m: {
+            readonly fontSize: "20px";
+            readonly lineHeight: "30px";
+            readonly letterSpacing: "-0.009em";
+            readonly tag: "h3";
+        };
+        readonly s: {
+            readonly fontSize: "18px";
+            readonly lineHeight: "28px";
+            readonly letterSpacing: "0";
+            readonly tag: "h3";
+        };
+    };
+    readonly body: {
+        readonly l: {
+            readonly fontSize: "16px";
+            readonly lineHeight: "24px";
+            readonly letterSpacing: "0.004em";
+            readonly tag: "p";
+        };
+        readonly m: {
+            readonly fontSize: "14px";
+            readonly lineHeight: "21px";
+            readonly letterSpacing: "0.006em";
+            readonly tag: "p";
+        };
+        readonly s: {
+            readonly fontSize: "12px";
+            readonly lineHeight: "16px";
+            readonly letterSpacing: "0.008em";
+            readonly tag: "p";
+        };
+    };
+};
+declare const variantWeights: {
+    readonly display: readonly ["", "medium", "semi-bold", "bold"];
+    readonly heading: readonly ["medium", "semi-bold", "bold"];
+    readonly title: readonly ["medium", "semi-bold", "bold"];
+    readonly body: readonly ["medium", "semi-bold", "bold"];
+};
+type VariantWeights = typeof variantWeights;
+type WeightSuffix<W> = W extends string ? (W extends '' ? '' : `-${W}`) : '';
+export type TypographyVariantFromOptions<Options extends TypographyVariantOptions> = {
+    [Category in keyof Options & keyof VariantWeights]: {
+        [Size in keyof Options[Category]]: `${string & Category}-${string & Size}${WeightSuffix<VariantWeights[Category][number]>}`;
+    }[keyof Options[Category]];
+}[keyof Options & keyof VariantWeights];
+export type TypographyDefaultVariant = TypographyVariantFromOptions<typeof defaultVariantOptions>;
+export type TypographyVariant = TypographyDefaultVariant | (string & {});
+export declare function mergeVariantOptions(variantOptions?: TypographyVariantOptions): TypographyVariantOptions;
+export declare function mergeVariantWeights(variantWeightsOptions?: Partial<Record<PropertyKey, readonly string[]>>): Record<PropertyKey, readonly string[]>;
+export declare function getVariantCssVars(variant: TypographyVariant | undefined, baseVars: Record<string, string>, fontFamilyVariant: string, variantOptions?: TypographyVariantOptions, variantWeightsOptions?: Partial<Record<PropertyKey, readonly string[]>>): Record<string, string>;
+export declare function getVariantTag(variant: TypographyVariant, variantOptions?: TypographyVariantOptions, variantWeightsOptions?: Partial<Record<PropertyKey, readonly string[]>>): keyof HTMLElementTagNameMap;
+export declare const variantToCssVars: Record<string, TypographyVariantConfig>;
+export {};

package/es/_internal/typography/src/variants.js

@@ -1,5 +1,5 @@
 const fontFamily = 'var(--u-font-famliy-variant)';
-const baseStyles = {
+export const defaultVariantOptions = {
     display: {
         l: {
             fontSize: '42px',
@@ -47,7 +47,12 @@ const baseStyles = {
             letterSpacing: '-0.009em',
             tag: 'h3'
         },
-        s: { fontSize: '18px', lineHeight: '28px', letterSpacing: '0', tag: 'h3' }
+        s: {
+            fontSize: '18px',
+            lineHeight: '28px',
+            letterSpacing: '0',
+            tag: 'h3'
+        }
     },
     body: {
         l: {
@@ -70,13 +75,21 @@ const baseStyles = {
         }
     }
 };
+const variantWeights = {
+    display: ['', 'medium', 'semi-bold', 'bold'],
+    heading: ['medium', 'semi-bold', 'bold'],
+    title: ['medium', 'semi-bold', 'bold'],
+    body: ['medium', 'semi-bold', 'bold']
+};
 const fontWeights = {
     medium: { weight: '500', style: 'medium' },
     'semi-bold': { weight: '600', style: 'semibold' },
-    bold: { weight: '700', style: 'bold' }
+    bold: { weight: '700', style: 'bold' },
+    '': { weight: '700', style: 'bold' }
 };
-function createVariant(category, size, weight) {
-    const base = baseStyles[category][size];
+function createVariant(options, category, size, weight) {
+    var _a, _b, _c;
+    const base = (_b = (_a = options === null || options === void 0 ? void 0 : options[category]) === null || _a === void 0 ? void 0 : _a[size]) !== null && _b !== void 0 ? _b : (_c = defaultVariantOptions[category]) === null || _c === void 0 ? void 0 : _c[size];
     const { weight: fontWeight, style: fontStyle } = fontWeights[weight];
     return {
         fontFamily,
@@ -88,45 +101,74 @@ function createVariant(category, size, weight) {
         tag: base.tag
     };
 }
-export function getVariantCssVars(variant, baseVars, fontFamilyVariant) {
-    if (!variant || !variantToCssVars[variant]) {
+export function mergeVariantOptions(variantOptions) {
+    if (!variantOptions)
+        return defaultVariantOptions;
+    const mergedOptions = {};
+    const categories = new Set([
+        ...Object.keys(defaultVariantOptions),
+        ...Object.keys(variantOptions)
+    ]);
+    categories.forEach((categoryKey) => {
+        const category = categoryKey;
+        mergedOptions[category] = Object.assign(Object.assign({}, (defaultVariantOptions[category] || {})), (variantOptions[category] || {}));
+    });
+    return mergedOptions;
+}
+export function mergeVariantWeights(variantWeightsOptions) {
+    if (!variantWeightsOptions)
+        return variantWeights;
+    const mergedWeights = {};
+    const categories = new Set([
+        ...Object.keys(variantWeights),
+        ...Object.keys(variantWeightsOptions)
+    ]);
+    categories.forEach((category) => {
+        const defaultWeights = variantWeights[category] || [];
+        const customWeights = variantWeightsOptions[category] || [];
+        const combined = [...defaultWeights];
+        customWeights.forEach((weight) => {
+            if (!combined.includes(weight)) {
+                combined.push(weight);
+            }
+        });
+        mergedWeights[category] = combined;
+    });
+    return mergedWeights;
+}
+function createVariantToCssVars(variantOptions, variantWeightsOptions) {
+    const configs = {};
+    const mergedWeights = mergeVariantWeights(variantWeightsOptions);
+    Object.entries(variantOptions).forEach(([category, sizes]) => {
+        const weights = mergedWeights[category] || [];
+        Object.keys(sizes).forEach((size) => {
+            weights.forEach((weight) => {
+                const variantKey = `${category}-${size}${weight ? `-${weight}` : ''}`;
+                configs[variantKey] = createVariant(variantOptions, category, size, weight);
+            });
+        });
+    });
+    return configs;
+}
+function resolveVariantConfigs(variantOptions, variantWeightsOptions) {
+    const hasCustomOptions = variantOptions && Object.keys(variantOptions).length > 0;
+    const hasCustomWeights = variantWeightsOptions && Object.keys(variantWeightsOptions).length > 0;
+    if (!hasCustomOptions && !hasCustomWeights) {
+        return variantToCssVars;
+    }
+    return createVariantToCssVars(mergeVariantOptions(variantOptions), variantWeightsOptions);
+}
+export function getVariantCssVars(variant, baseVars, fontFamilyVariant, variantOptions, variantWeightsOptions) {
+    const variantStyles = variant
+        ? resolveVariantConfigs(variantOptions, variantWeightsOptions)[variant]
+        : undefined;
+    if (!variantStyles) {
         return baseVars;
     }
-    const variantStyles = variantToCssVars[variant];
     return Object.assign(Object.assign({}, baseVars), { '--u-font-famliy-variant': fontFamilyVariant, '--u-variant-font-size': variantStyles.fontSize, '--u-variant-font-weight': variantStyles.fontWeight, '--u-variant-line-height': variantStyles.lineHeight, '--u-variant-font-family': variantStyles.fontFamily, '--u-variant-font-style': variantStyles.fontStyle, '--u-variant-letter-spacing': variantStyles.letterSpacing });
 }
-export function getVariantTag(variant) {
-    return variantToCssVars[variant].tag;
+export function getVariantTag(variant, variantOptions, variantWeightsOptions) {
+    var _a;
+    return (_a = resolveVariantConfigs(variantOptions, variantWeightsOptions)[variant]) === null || _a === void 0 ? void 0 : _a.tag;
 }
-export const variantToCssVars = {
-    // Display variants
-    'display-l': createVariant('display', 'l', 'bold'),
-    'display-s': createVariant('display', 's', 'bold'),
-    // Heading variants
-    'heading-l-semi-bold': createVariant('heading', 'l', 'semi-bold'),
-    'heading-l-bold': createVariant('heading', 'l', 'bold'),
-    'heading-m-semi-bold': createVariant('heading', 'm', 'semi-bold'),
-    'heading-m-bold': createVariant('heading', 'm', 'bold'),
-    'heading-s-semi-bold': createVariant('heading', 's', 'semi-bold'),
-    'heading-s-bold': createVariant('heading', 's', 'bold'),
-    // Title variants
-    'title-l-medium': createVariant('title', 'l', 'medium'),
-    'title-l-semi-bold': createVariant('title', 'l', 'semi-bold'),
-    'title-l-bold': createVariant('title', 'l', 'bold'),
-    'title-m-medium': createVariant('title', 'm', 'medium'),
-    'title-m-semi-bold': createVariant('title', 'm', 'semi-bold'),
-    'title-m-bold': createVariant('title', 'm', 'bold'),
-    'title-s-medium': createVariant('title', 's', 'medium'),
-    'title-s-semi-bold': createVariant('title', 's', 'semi-bold'),
-    'title-s-bold': createVariant('title', 's', 'bold'),
-    // Body variants
-    'body-l-medium': createVariant('body', 'l', 'medium'),
-    'body-l-semi-bold': createVariant('body', 'l', 'semi-bold'),
-    'body-l-bold': createVariant('body', 'l', 'bold'),
-    'body-m-medium': createVariant('body', 'm', 'medium'),
-    'body-m-semi-bold': createVariant('body', 'm', 'semi-bold'),
-    'body-m-bold': createVariant('body', 'm', 'bold'),
-    'body-s-medium': createVariant('body', 's', 'medium'),
-    'body-s-semi-bold': createVariant('body', 's', 'semi-bold'),
-    'body-s-bold': createVariant('body', 's', 'bold')
-};
+export const variantToCssVars = createVariantToCssVars(defaultVariantOptions, variantWeights);

package/es/_internal/typography/styles/dark.js

@@ -1,4 +1,4 @@
-import { commonDark } from '../../../styles';
+import { commonDark } from '../../../_styles/common';
 import { self } from './light';
 const typographyDark = {
     name: 'Typography',

package/es/_internal/typography/styles/light.d.ts

@@ -1,5 +1,5 @@
 import { Theme } from '../../../_mixins';
-import { ThemeCommonVars } from '../../../config-provider';
+import type { ThemeCommonVars } from '../../../config-provider';
 export declare const self: (vars: ThemeCommonVars) => {
     margin: string;
     aTextColor: string;

package/es/_internal/typography/styles/light.js

@@ -1,4 +1,4 @@
-import { commonLight } from '../../../styles';
+import { commonLight } from '../../../_styles/common';
 export const self = (vars) => {
     const { borderRadiusSmall, brandPrimary500, elementsQuaternary, textPrimary, brandQuaternary500, staticRed, staticOrange, staticGreen, elementsTertiary, fontBodyMedium, lineHeightBodyMedium, codeBorder } = vars;
     return {

package/es/affix/src/Affix.d.ts

@@ -27,7 +27,7 @@ export declare const affixProps: {
         readonly default: undefined;
     };
 };
-export declare const affixPropKeys: ("top" | "bottom" | "position" | "target" | "listenTo" | "triggerTop" | "triggerBottom" | "offsetTop" | "offsetBottom")[];
+export declare const affixPropKeys: ("top" | "bottom" | "listenTo" | "triggerTop" | "triggerBottom" | "position" | "offsetTop" | "offsetBottom" | "target")[];
 export type AffixProps = ExtractPublicPropTypes<typeof affixProps>;
 declare const _default: import("vue").DefineComponent<{
     readonly listenTo: PropType<string | ScrollTarget | (() => HTMLElement) | undefined>;
@@ -85,9 +85,9 @@ declare const _default: import("vue").DefineComponent<{
         readonly default: undefined;
     };
 }>>, {
-    readonly position: "absolute" | "fix";
-    readonly target: (() => HTMLElement) | undefined;
+    readonly position: "fix" | "absolute";
     readonly offsetTop: number | undefined;
     readonly offsetBottom: number | undefined;
+    readonly target: (() => HTMLElement) | undefined;
 }, {}>;
 export default _default;

package/es/alert/src/Alert.d.ts

@@ -929,11 +929,11 @@ declare const _default: import("vue").DefineComponent<{
         descriptionSpaceBanner: string;
     }, any>>>;
 }>>, {
-    type: "default" | "primary" | "info" | "success" | "warning" | "error";
+    type: "default" | "info" | "warning" | "error" | "success" | "primary";
     showIcon: boolean;
-    closable: boolean;
+    layoutType: "banner" | "alert";
     rounded: boolean;
-    layoutType: "alert" | "banner";
     actionsHorizontal: boolean;
+    closable: boolean;
 }, {}>;
 export default _default;

package/es/anchor/src/AnchorAdapter.d.ts

@@ -280,15 +280,15 @@ declare const _default: import("vue").DefineComponent<{
 }>>, {
     readonly type: "block" | "rail";
     readonly top: number;
-    readonly position: "absolute" | "fix";
-    readonly target: (() => HTMLElement) | undefined;
-    readonly affix: boolean;
-    readonly offsetTop: number | undefined;
-    readonly offsetBottom: number | undefined;
     readonly showRail: boolean;
     readonly showBackground: boolean;
     readonly bound: number;
     readonly internalScrollable: boolean;
     readonly ignoreGap: boolean;
+    readonly position: "fix" | "absolute";
+    readonly offsetTop: number | undefined;
+    readonly offsetBottom: number | undefined;
+    readonly target: (() => HTMLElement) | undefined;
+    readonly affix: boolean;
 }, {}>;
 export default _default;

package/es/auto-complete/src/AutoComplete.d.ts

@@ -1608,12 +1608,12 @@ declare const _default: import("vue").DefineComponent<{
     readonly loading: boolean;
     readonly bordered: boolean | undefined;
     readonly to: string | boolean | HTMLElement;
+    readonly clearable: boolean;
+    readonly defaultValue: string | null;
     readonly resetMenuOnOptionsChange: boolean;
     readonly placement: FollowerPlacement;
-    readonly defaultValue: string | null;
-    readonly clearable: boolean;
-    readonly options: AutoCompleteOptions;
     readonly blurAfterSelect: boolean;
     readonly clearAfterSelect: boolean;
+    readonly options: AutoCompleteOptions;
 }, {}>;
 export default _default;

package/es/avatar/src/Avatar.d.ts

@@ -243,8 +243,8 @@ declare const _default: import("vue").DefineComponent<{
     readonly disabled: boolean;
     readonly loading: boolean;
     readonly bordered: boolean;
-    readonly round: boolean;
     readonly circle: boolean;
+    readonly round: boolean;
     readonly lazy: boolean;
 }, {}>;
 export default _default;