ant-design-x-vue 0.0.1

package/dist/typings/_util/cssinjs/index.d.ts

@@ -0,0 +1,197 @@
+import useCacheToken from './hooks/useCacheToken';
+import useCSSVarRegister from './hooks/useCSSVarRegister';
+import type { CSSInterpolation, CSSObject } from './hooks/useStyleRegister';
+import useStyleRegister, { extractStyle } from './hooks/useStyleRegister';
+import Keyframes from './Keyframes';
+import type { Linter } from './linters';
+import { legacyNotSelectorLinter, logicalPropertiesLinter, parentSelectorLinter } from './linters';
+import type { StyleContextProps, StyleProviderProps } from './StyleContext';
+import { createCache, useStyleInject, useStyleProvider, StyleProvider } from './StyleContext';
+import type { DerivativeFunc, TokenType } from './theme';
+import { createTheme, Theme } from './theme';
+import type { Transformer } from './transformers/interface';
+import legacyLogicalPropertiesTransformer from './transformers/legacyLogicalProperties';
+import px2remTransformer from './transformers/px2rem';
+import { unit, token2CSSVar } from './util';
+declare const cssinjs: {
+    Theme: typeof Theme;
+    createTheme: typeof createTheme;
+    useStyleRegister: typeof useStyleRegister;
+    useCacheToken: typeof useCacheToken;
+    createCache: typeof createCache;
+    useStyleInject: () => import("vue").ShallowRef<Partial<StyleContextProps>>;
+    useStyleProvider: (props: import("./StyleContext").UseStyleProviderProps) => import("vue").ShallowRef<Partial<StyleContextProps>, Partial<StyleContextProps>>;
+    Keyframes: typeof Keyframes;
+    extractStyle: typeof extractStyle;
+    legacyLogicalPropertiesTransformer: Transformer;
+    px2remTransformer: (options?: import("./transformers/px2rem").Options) => Transformer;
+    logicalPropertiesLinter: Linter;
+    legacyNotSelectorLinter: Linter;
+    parentSelectorLinter: Linter;
+    StyleProvider: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: import("vue").PropType<import("./Cache").default>;
+                default: import("./Cache").default;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: import("vue").PropType<import("./StyleContext").HashPriority>;
+                default: import("./StyleContext").HashPriority;
+            };
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: import("vue").PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: import("./Cache").default;
+            defaultCache: boolean;
+            hashPriority: import("./StyleContext").HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            autoClear: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            mock: {
+                type: import("vue").PropType<"server" | "client">;
+                default: "server" | "client";
+            };
+            cache: {
+                type: import("vue").PropType<import("./Cache").default>;
+                default: import("./Cache").default;
+            };
+            defaultCache: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hashPriority: {
+                type: import("vue").PropType<import("./StyleContext").HashPriority>;
+                default: import("./StyleContext").HashPriority;
+            };
+            container: {
+                type: import("vue").PropType<Element | ShadowRoot>;
+                default: Element | ShadowRoot;
+            };
+            ssrInline: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            transformers: {
+                type: import("vue").PropType<Transformer[]>;
+                default: Transformer[];
+            };
+            linters: {
+                type: import("vue").PropType<Linter[]>;
+                default: Linter[];
+            };
+        }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }>[], {}, {}, {}, {
+            autoClear: boolean;
+            mock: "server" | "client";
+            cache: import("./Cache").default;
+            defaultCache: boolean;
+            hashPriority: import("./StyleContext").HashPriority;
+            container: Element | ShadowRoot;
+            ssrInline: boolean;
+            transformers: Transformer[];
+            linters: Linter[];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        autoClear: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        mock: {
+            type: import("vue").PropType<"server" | "client">;
+            default: "server" | "client";
+        };
+        cache: {
+            type: import("vue").PropType<import("./Cache").default>;
+            default: import("./Cache").default;
+        };
+        defaultCache: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hashPriority: {
+            type: import("vue").PropType<import("./StyleContext").HashPriority>;
+            default: import("./StyleContext").HashPriority;
+        };
+        container: {
+            type: import("vue").PropType<Element | ShadowRoot>;
+            default: Element | ShadowRoot;
+        };
+        ssrInline: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        transformers: {
+            type: import("vue").PropType<Transformer[]>;
+            default: Transformer[];
+        };
+        linters: {
+            type: import("vue").PropType<Linter[]>;
+            default: Linter[];
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        autoClear: boolean;
+        mock: "server" | "client";
+        cache: import("./Cache").default;
+        defaultCache: boolean;
+        hashPriority: import("./StyleContext").HashPriority;
+        container: Element | ShadowRoot;
+        ssrInline: boolean;
+        transformers: Transformer[];
+        linters: Linter[];
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & (import("vue").VNodeProps & (import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin));
+};
+export { Theme, createTheme, useStyleRegister, useCacheToken, createCache, useStyleInject, useStyleProvider, Keyframes, extractStyle, legacyLogicalPropertiesTransformer, px2remTransformer, logicalPropertiesLinter, legacyNotSelectorLinter, parentSelectorLinter, StyleProvider, unit, token2CSSVar, useCSSVarRegister, };
+export type { TokenType, CSSObject, CSSInterpolation, DerivativeFunc, Transformer, Linter, StyleContextProps, StyleProviderProps, };
+export declare const _experimental: {
+    supportModernCSS: () => boolean;
+};
+export default cssinjs;

package/dist/typings/_util/cssinjs/linters/contentQuotesLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/typings/_util/cssinjs/linters/hashedAnimationLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/typings/_util/cssinjs/linters/index.d.ts

@@ -0,0 +1,6 @@
+export { default as contentQuotesLinter } from './contentQuotesLinter';
+export { default as hashedAnimationLinter } from './hashedAnimationLinter';
+export type { Linter } from './interface';
+export { default as legacyNotSelectorLinter } from './legacyNotSelectorLinter';
+export { default as logicalPropertiesLinter } from './logicalPropertiesLinter';
+export { default as parentSelectorLinter } from './parentSelectorLinter';

package/dist/typings/_util/cssinjs/linters/interface.d.ts

@@ -0,0 +1,8 @@
+export interface LinterInfo {
+    path?: string;
+    hashId?: string;
+    parentSelectors: string[];
+}
+export interface Linter {
+    (key: string, value: string | number, info: LinterInfo): void;
+}

package/dist/typings/_util/cssinjs/linters/legacyNotSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/typings/_util/cssinjs/linters/logicalPropertiesLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from './interface';
+declare const linter: Linter;
+export default linter;

package/dist/typings/_util/cssinjs/linters/parentSelectorLinter.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from '..';
+declare const linter: Linter;
+export default linter;

package/dist/typings/_util/cssinjs/linters/utils.d.ts

@@ -0,0 +1,2 @@
+import type { LinterInfo } from './interface';
+export declare function lintWarning(message: string, info: LinterInfo): void;

package/dist/typings/_util/cssinjs/theme/Theme.d.ts

@@ -0,0 +1,11 @@
+import type { DerivativeFunc, TokenType } from './interface';
+/**
+ * Theme with algorithms to derive tokens from design tokens.
+ * Use `createTheme` first which will help to manage the theme instance cache.
+ */
+export default class Theme<DesignToken extends TokenType, DerivativeToken extends TokenType> {
+    private derivatives;
+    readonly id: number;
+    constructor(derivatives: DerivativeFunc<DesignToken, DerivativeToken> | DerivativeFunc<DesignToken, DerivativeToken>[]);
+    getDerivativeToken(token: DesignToken): DerivativeToken;
+}

package/dist/typings/_util/cssinjs/theme/ThemeCache.d.ts

@@ -0,0 +1,20 @@
+import type Theme from './Theme';
+import type { DerivativeFunc } from './interface';
+type DerivativeOptions = DerivativeFunc<any, any>[];
+export declare function sameDerivativeOption(left: DerivativeOptions, right: DerivativeOptions): boolean;
+export default class ThemeCache {
+    static MAX_CACHE_SIZE: number;
+    static MAX_CACHE_OFFSET: number;
+    private readonly cache;
+    private keys;
+    private cacheCallTimes;
+    constructor();
+    size(): number;
+    private internalGet;
+    get(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+    has(derivativeOption: DerivativeOptions): boolean;
+    set(derivativeOption: DerivativeOptions, value: Theme<any, any>): void;
+    private deleteByPath;
+    delete(derivativeOption: DerivativeOptions): Theme<any, any> | undefined;
+}
+export {};

package/dist/typings/_util/cssinjs/theme/createTheme.d.ts

@@ -0,0 +1,6 @@
+import Theme from './Theme';
+import type { DerivativeFunc, TokenType } from './interface';
+/**
+ * Same as new Theme, but will always return same one if `derivative` not changed.
+ */
+export default function createTheme<DesignToken extends TokenType, DerivativeToken extends TokenType>(derivatives: DerivativeFunc<DesignToken, DerivativeToken>[] | DerivativeFunc<DesignToken, DerivativeToken>): Theme<any, any>;

package/dist/typings/_util/cssinjs/theme/index.d.ts

@@ -0,0 +1,4 @@
+export { default as createTheme } from './createTheme';
+export { default as Theme } from './Theme';
+export { default as ThemeCache } from './ThemeCache';
+export type { TokenType, DerivativeFunc } from './interface';

package/dist/typings/_util/cssinjs/theme/interface.d.ts

@@ -0,0 +1,2 @@
+export type TokenType = object;
+export type DerivativeFunc<DesignToken extends TokenType, DerivativeToken extends TokenType> = (designToken: DesignToken, derivativeToken?: DerivativeToken) => DerivativeToken;

package/dist/typings/_util/cssinjs/transformers/interface.d.ts

@@ -0,0 +1,4 @@
+import type { CSSObject } from '..';
+export interface Transformer {
+    visit?: (cssObj: CSSObject) => CSSObject;
+}

package/dist/typings/_util/cssinjs/transformers/legacyLogicalProperties.d.ts

@@ -0,0 +1,12 @@
+import type { Transformer } from './interface';
+/**
+ * Convert css logical properties to legacy properties.
+ * Such as: `margin-block-start` to `margin-top`.
+ * Transform list:
+ * - inset
+ * - margin
+ * - padding
+ * - border
+ */
+declare const transform: Transformer;
+export default transform;

package/dist/typings/_util/cssinjs/transformers/px2rem.d.ts

@@ -0,0 +1,20 @@
+import type { Transformer } from './interface';
+export interface Options {
+    /**
+     * The root font size.
+     * @default 16
+     */
+    rootValue?: number;
+    /**
+     * The decimal numbers to allow the REM units to grow to.
+     * @default 5
+     */
+    precision?: number;
+    /**
+     * Whether to allow px to be converted in media queries.
+     * @default false
+     */
+    mediaQuery?: boolean;
+}
+declare const transform: (options?: Options) => Transformer;
+export default transform;

package/dist/typings/_util/cssinjs/util.d.ts

@@ -0,0 +1,28 @@
+export declare const ATTR_TOKEN = "data-token-hash";
+export declare const ATTR_MARK = "data-css-hash";
+export declare const ATTR_CACHE_PATH = "data-cache-path";
+export type TokenWithCSSVar<V, T extends Record<string, V> = Record<string, V>> = {
+    [key in keyof T]?: string | V;
+};
+export declare function flattenToken(token: any): string;
+/**
+ * Convert derivative token to key string
+ */
+export declare function token2key(token: any, salt: string): string;
+export declare function supportLayer(): boolean;
+export declare function supportWhere(): boolean;
+export declare function supportLogicProps(): boolean;
+export declare const isClientSide: boolean;
+export declare function unit(num: string | number): string;
+export declare const token2CSSVar: (token: string, prefix?: string) => string;
+export declare function toStyleStr(style: string, tokenKey?: string, styleId?: string, customizeAttrs?: Record<string, string>, plain?: boolean): string;
+export declare const serializeCSSVar: <T extends Record<string, any>>(cssVars: T, hashId: string, options?: {
+    scope?: string;
+}) => string;
+export declare const transformToken: <V, T extends Record<string, V> = Record<string, V>>(token: T, themeKey: string, config?: {
+    prefix?: string;
+    ignore?: { [key in keyof T]?: boolean; };
+    unitless?: { [key in keyof T]?: boolean; };
+    preserve?: { [key in keyof T]?: boolean; };
+    scope?: string;
+}) => [TokenWithCSSVar<V, T>, string];

package/dist/typings/_util/cssinjs-utils/_util/hooks/useUniqueMemo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Like `useMemo`, but this hook result will be shared across all instances.
+ */
+declare function useUniqueMemo<T>(memoFn: () => T, deps: unknown[]): import("vue").ComputedRef<T>;
+export default useUniqueMemo;

package/dist/typings/_util/cssinjs-utils/hooks/useCSP.d.ts

@@ -0,0 +1,8 @@
+export type UseCSP = () => {
+    nonce?: string;
+};
+/**
+ * Provide a default hook since not everyone needs to config this.
+ */
+declare const useDefaultCSP: UseCSP;
+export default useDefaultCSP;

package/dist/typings/_util/cssinjs-utils/hooks/usePrefix.d.ts

@@ -0,0 +1,11 @@
+export type UsePrefix = () => {
+    /**
+     * All the component use `@ant-design/cssinjs-utils` should have same `rootPrefixCls`.
+     */
+    rootPrefixCls: string;
+    /**
+     * `iconPrefixCls` comes from the setting of `@ant-design/icons`.
+     * Here maybe little coupling but everyone need use this.
+     */
+    iconPrefixCls: string;
+};

package/dist/typings/_util/cssinjs-utils/hooks/useToken.d.ts

@@ -0,0 +1,20 @@
+import type { Theme, TokenType } from '../../cssinjs';
+import type { OverrideTokenMap, TokenMap, GlobalToken } from '../interface';
+export type TokenMapWithTheme<CompTokenMap extends TokenMap, AliasToken extends TokenType, DesignToken extends TokenType> = {
+    [key in keyof OverrideTokenMap<CompTokenMap, AliasToken>]?: OverrideTokenMap<CompTokenMap, AliasToken>[key] & {
+        theme?: Theme<DesignToken, AliasToken>;
+    };
+};
+export interface UseTokenReturn<CompTokenMap extends TokenMap, AliasToken extends TokenType, DesignToken extends TokenType> {
+    token: GlobalToken<CompTokenMap, AliasToken>;
+    realToken?: GlobalToken<CompTokenMap, AliasToken>;
+    theme?: Theme<DesignToken, AliasToken>;
+    components?: TokenMapWithTheme<CompTokenMap, DesignToken, AliasToken>;
+    hashId?: string;
+    hashed?: string | boolean;
+    cssVar?: {
+        prefix?: string;
+        key?: string;
+    };
+}
+export type UseToken<CompTokenMap extends TokenMap, DesignToken extends TokenType, AliasToken extends TokenType> = () => UseTokenReturn<CompTokenMap, DesignToken, AliasToken>;

package/dist/typings/_util/cssinjs-utils/index.d.ts

@@ -0,0 +1,6 @@
+export { default as genStyleUtils } from './util/genStyleUtils';
+export { default as genCalc } from './util/calc';
+export { default as statisticToken, merge as mergeToken, statistic } from './util/statistic';
+export type { OverrideTokenMap, TokenMap, TokenMapKey, GlobalTokenWithComponent, ComponentToken, ComponentTokenKey, GlobalToken, } from './interface';
+export type { default as AbstractCalculator } from './util/calc/calculator';
+export type { FullToken, GetDefaultToken, GetDefaultTokenFn, GenStyleFn, TokenWithCommonCls, CSSUtil, } from './util/genStyleUtils';

package/dist/typings/_util/cssinjs-utils/interface/components.d.ts

@@ -0,0 +1,10 @@
+import type { TokenType } from '../../cssinjs';
+export type TokenMap = Record<PropertyKey, any>;
+export type TokenMapKey<CompTokenMap extends TokenMap> = Extract<keyof CompTokenMap, string>;
+export type GlobalToken<CompTokenMap extends TokenMap, AliasToken extends TokenType> = AliasToken & CompTokenMap;
+export type OverrideTokenMap<CompTokenMap extends TokenMap, AliasToken extends TokenType> = {
+    [key in keyof CompTokenMap]: Partial<CompTokenMap[key]> & Partial<AliasToken>;
+};
+export type GlobalTokenWithComponent<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = GlobalToken<CompTokenMap, AliasToken> & CompTokenMap[C];
+export type ComponentToken<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = Exclude<OverrideTokenMap<CompTokenMap, AliasToken>[C], undefined>;
+export type ComponentTokenKey<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = keyof ComponentToken<CompTokenMap, AliasToken, C>;

package/dist/typings/_util/cssinjs-utils/interface/index.d.ts

@@ -0,0 +1,3 @@
+import { VNode } from 'vue';
+export type { OverrideTokenMap, TokenMap, TokenMapKey, GlobalTokenWithComponent, ComponentToken, ComponentTokenKey, GlobalToken, } from './components';
+export type UseComponentStyleResult = [(node: VNode) => VNode, string];

package/dist/typings/_util/cssinjs-utils/util/calc/CSSCalculator.d.ts

@@ -0,0 +1,15 @@
+import AbstractCalculator from './calculator';
+export default class CSSCalculator extends AbstractCalculator {
+    result: string;
+    unitlessCssVar: Set<string>;
+    lowPriority?: boolean;
+    constructor(num: number | string | AbstractCalculator, unitlessCssVar: Set<string>);
+    add(num: number | string | AbstractCalculator): this;
+    sub(num: number | string | AbstractCalculator): this;
+    mul(num: number | string | AbstractCalculator): this;
+    div(num: number | string | AbstractCalculator): this;
+    getResult(force?: boolean): string;
+    equal(options?: {
+        unit?: boolean;
+    }): string;
+}

package/dist/typings/_util/cssinjs-utils/util/calc/NumCalculator.d.ts

@@ -0,0 +1,11 @@
+import AbstractCalculator from './calculator';
+declare class NumCalculator extends AbstractCalculator {
+    result: number;
+    constructor(num: number | string | AbstractCalculator);
+    add(num: number | string | AbstractCalculator): this;
+    sub(num: number | string | AbstractCalculator): this;
+    mul(num: number | string | AbstractCalculator): this;
+    div(num: number | string | AbstractCalculator): this;
+    equal(): number;
+}
+export default NumCalculator;

package/dist/typings/_util/cssinjs-utils/util/calc/calculator.d.ts

@@ -0,0 +1,30 @@
+declare abstract class AbstractCalculator {
+    /**
+     * @descCN 计算两数的和，例如：1 + 2
+     * @descEN Calculate the sum of two numbers, e.g. 1 + 2
+     */
+    abstract add(num: number | string | AbstractCalculator): this;
+    /**
+     * @descCN 计算两数的差，例如：1 - 2
+     * @descEN Calculate the difference between two numbers, e.g. 1 - 2
+     */
+    abstract sub(num: number | string | AbstractCalculator): this;
+    /**
+     * @descCN 计算两数的积，例如：1 * 2
+     * @descEN Calculate the product of two numbers, e.g. 1 * 2
+     */
+    abstract mul(num: number | string | AbstractCalculator): this;
+    /**
+     * @descCN 计算两数的商，例如：1 / 2
+     * @descEN Calculate the quotient of two numbers, e.g. 1 / 2
+     */
+    abstract div(num: number | string | AbstractCalculator): this;
+    /**
+     * @descCN 获取计算结果
+     * @descEN Get the calculation result
+     */
+    abstract equal(options?: {
+        unit?: boolean;
+    }): string | number;
+}
+export default AbstractCalculator;

package/dist/typings/_util/cssinjs-utils/util/calc/index.d.ts

@@ -0,0 +1,5 @@
+import type AbstractCalculator from './calculator';
+import CSSCalculator from './CSSCalculator';
+import NumCalculator from './NumCalculator';
+declare const genCalc: (type: "css" | "js", unitlessCssVar: Set<string>) => (num: number | string | AbstractCalculator) => CSSCalculator | NumCalculator;
+export default genCalc;

package/dist/typings/_util/cssinjs-utils/util/genStyleUtils.d.ts

@@ -0,0 +1,116 @@
+import type { CSSInterpolation, CSSObject, TokenType } from '../../cssinjs';
+import { useStyleRegister } from '../../cssinjs';
+import type { ComponentTokenKey, GlobalTokenWithComponent, TokenMap, TokenMapKey, UseComponentStyleResult } from '../interface';
+import type AbstractCalculator from './calc/calculator';
+import { MaybeRefOrGetter, type VNode } from 'vue';
+import type { UseCSP } from '../hooks/useCSP';
+import type { UsePrefix } from '../hooks/usePrefix';
+import type { UseToken } from '../hooks/useToken';
+type LayerConfig = Parameters<typeof useStyleRegister>[0]['layer'];
+export interface StyleInfo {
+    hashId: string;
+    prefixCls: string;
+    rootPrefixCls: string;
+    iconPrefixCls: string;
+}
+export type CSSUtil = {
+    calc: (number: any) => AbstractCalculator;
+    max: (...values: (number | string)[]) => number | string;
+    min: (...values: (number | string)[]) => number | string;
+};
+export type TokenWithCommonCls<T> = T & {
+    /** Wrap component class with `.` prefix */
+    componentCls: string;
+    /** Origin prefix which do not have `.` prefix */
+    prefixCls: string;
+    /** Wrap icon class with `.` prefix */
+    iconCls: string;
+    /** Wrap ant prefixCls class with `.` prefix */
+    antCls: string;
+} & CSSUtil;
+export type FullToken<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = TokenWithCommonCls<GlobalTokenWithComponent<CompTokenMap, AliasToken, C>>;
+export type GenStyleFn<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = (token: FullToken<CompTokenMap, AliasToken, C>, info: StyleInfo) => CSSInterpolation;
+export type GetDefaultTokenFn<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = (token: AliasToken & Partial<CompTokenMap[C]>) => CompTokenMap[C];
+export type GetDefaultToken<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>> = null | CompTokenMap[C] | GetDefaultTokenFn<CompTokenMap, AliasToken, C>;
+export interface SubStyleComponentProps {
+    prefixCls: string;
+    rootCls?: string;
+}
+export type CSSVarRegisterProps = {
+    rootCls: string;
+    component: string;
+    cssVar: {
+        prefix?: string;
+        key?: string;
+    };
+};
+type GetResetStylesConfig = {
+    prefix: ReturnType<UsePrefix>;
+    csp: ReturnType<UseCSP>;
+};
+export type GetResetStyles<AliasToken extends TokenType> = (token: AliasToken, config?: GetResetStylesConfig) => CSSInterpolation;
+export type GetCompUnitless<CompTokenMap extends TokenMap, AliasToken extends TokenType> = <C extends TokenMapKey<CompTokenMap>>(component: C | [C, string]) => Partial<Record<ComponentTokenKey<CompTokenMap, AliasToken, C>, boolean>>;
+declare function genStyleUtils<CompTokenMap extends TokenMap, AliasToken extends TokenType, DesignToken extends TokenType>(config: {
+    usePrefix: UsePrefix;
+    useToken: UseToken<CompTokenMap, AliasToken, DesignToken>;
+    useCSP?: UseCSP;
+    getResetStyles?: GetResetStyles<AliasToken>;
+    getCommonStyle?: (token: AliasToken, componentPrefixCls: string, rootCls?: string, resetFont?: boolean) => CSSObject;
+    getCompUnitless?: GetCompUnitless<CompTokenMap, AliasToken>;
+    layer?: LayerConfig;
+}): {
+    genStyleHooks: <C extends TokenMapKey<CompTokenMap>>(component: C | [C, string], styleFn: GenStyleFn<CompTokenMap, AliasToken, C>, getDefaultToken?: GetDefaultToken<CompTokenMap, AliasToken, C>, options?: {
+        resetStyle?: boolean;
+        resetFont?: boolean;
+        deprecatedTokens?: [ComponentTokenKey<CompTokenMap, AliasToken, C>, ComponentTokenKey<CompTokenMap, AliasToken, C>][];
+        /**
+         * Component tokens that do not need unit.
+         */
+        unitless?: Partial<Record<ComponentTokenKey<CompTokenMap, AliasToken, C>, boolean>>;
+        /**
+         * Only use component style in client side. Ignore in SSR.
+         */
+        clientOnly?: boolean;
+        /**
+         * Set order of component style.
+         * @default -999
+         */
+        order?: number;
+        /**
+         * Whether generate styles
+         * @default true
+         */
+        injectStyle?: boolean;
+    }) => (prefixCls: MaybeRefOrGetter<string>, rootCls?: string) => readonly [(node: VNode) => VNode, string, string];
+    genSubStyleComponent: <C extends TokenMapKey<CompTokenMap>>(componentName: C | [C, string], styleFn: GenStyleFn<CompTokenMap, AliasToken, C>, getDefaultToken?: GetDefaultToken<CompTokenMap, AliasToken, C>, options?: {
+        resetStyle?: boolean;
+        resetFont?: boolean;
+        deprecatedTokens?: [ComponentTokenKey<CompTokenMap, AliasToken, C>, ComponentTokenKey<CompTokenMap, AliasToken, C>][];
+        /**
+         * Only use component style in client side. Ignore in SSR.
+         */
+        clientOnly?: boolean;
+        /**
+         * Set order of component style. Default is -999.
+         */
+        order?: number;
+        injectStyle?: boolean;
+        unitless?: Partial<Record<ComponentTokenKey<CompTokenMap, AliasToken, C>, boolean>>;
+    }) => any;
+    genComponentStyleHook: <C extends TokenMapKey<CompTokenMap>>(componentName: C | [C, string], styleFn: GenStyleFn<CompTokenMap, AliasToken, C>, getDefaultToken?: GetDefaultToken<CompTokenMap, AliasToken, C>, options?: {
+        resetStyle?: boolean;
+        resetFont?: boolean;
+        deprecatedTokens?: [ComponentTokenKey<CompTokenMap, AliasToken, C>, ComponentTokenKey<CompTokenMap, AliasToken, C>][];
+        /**
+         * Only use component style in client side. Ignore in SSR.
+         */
+        clientOnly?: boolean;
+        /**
+         * Set order of component style. Default is -999.
+         */
+        order?: number;
+        injectStyle?: boolean;
+        unitless?: Partial<Record<ComponentTokenKey<CompTokenMap, AliasToken, C>, boolean>>;
+    }) => (prefixCls: string, rootCls?: string) => UseComponentStyleResult;
+};
+export default genStyleUtils;

package/dist/typings/_util/cssinjs-utils/util/getCompVarPrefix.d.ts

@@ -0,0 +1,2 @@
+declare const getCompVarPrefix: (component: string, prefix?: string) => string;
+export default getCompVarPrefix;

package/dist/typings/_util/cssinjs-utils/util/getComponentToken.d.ts

@@ -0,0 +1,9 @@
+import type { TokenMap, TokenMapKey, ComponentTokenKey, GlobalToken } from '../interface';
+import type { TokenType } from '../../cssinjs';
+declare function getComponentToken<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>>(component: C, token: GlobalToken<CompTokenMap, AliasToken>, defaultToken: CompTokenMap[C], options?: {
+    deprecatedTokens?: [
+        ComponentTokenKey<CompTokenMap, AliasToken, C>,
+        ComponentTokenKey<CompTokenMap, AliasToken, C>
+    ][];
+}): any;
+export default getComponentToken;