@cck-ui/core 0.2.0

package/lib/core/config-provider/color-functions/parse-theme-color/parse-theme-color.d.ts

@@ -0,0 +1,17 @@
+import { CColorScheme, CColorShade, CTheme } from '../../theme.types';
+import type { CssVariable } from '../../../box';
+interface ParseThemeColorOptions {
+    color: unknown;
+    theme: CTheme;
+    colorScheme?: CColorScheme;
+}
+interface ParseThemeColorResult {
+    color: string;
+    value: string;
+    shade: CColorShade | undefined;
+    variable: CssVariable | undefined;
+    isThemeColor: boolean;
+    isLight: boolean;
+}
+export declare function parseThemeColor({ color, colorScheme, theme }: ParseThemeColorOptions): ParseThemeColorResult;
+export {};

package/lib/core/config-provider/color-functions/rgba/rgba.d.ts

@@ -0,0 +1,2 @@
+export declare function rgba(color: string, alpha: number): string;
+export declare const alpha: typeof rgba;

package/lib/core/config-provider/color-functions/to-rgba/to-rgba.d.ts

@@ -0,0 +1,7 @@
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare function toRgba(color: string): RGBA;

package/lib/core/config-provider/config-provider.context.d.ts

@@ -0,0 +1,30 @@
+import { CColorScheme, CTheme } from './theme.types';
+import { ConvertCSSVariablesInput } from './convert-css-variables';
+export interface CStylesTransform {
+    sx?: () => (sx: any) => string;
+    styles?: () => (styles: any, payload: any) => Record<string, string>;
+}
+interface CContextValue {
+    colorScheme: CColorScheme;
+    setColorScheme: (colorScheme: CColorScheme) => void;
+    clearColorScheme: () => void;
+    getRootElement: () => HTMLElement | undefined;
+    classNamesPrefix: string;
+    getStyleNonce?: () => string | undefined;
+    cssVariablesResolver?: (theme: CTheme) => ConvertCSSVariablesInput;
+    cssVariablesSelector: string;
+    withStaticClasses: boolean;
+    headless?: boolean;
+    stylesTransform?: CStylesTransform;
+    env?: 'default' | 'test';
+}
+export declare function useConfigContext(): CContextValue;
+export declare function useCckCssVariablesResolver(): ((theme: CTheme) => ConvertCSSVariablesInput) | undefined;
+export declare function useCckClassNamesPrefix(): string;
+export declare function useCckStyleNonce(): (() => string | undefined) | undefined;
+export declare function useCckWithStaticClasses(): boolean;
+export declare function useCckIsHeadless(): boolean | undefined;
+export declare function useCckSxTransform(): (() => (sx: any) => string) | undefined;
+export declare function useCckStylesTransform(): (() => (styles: any, payload: any) => Record<string, string>) | undefined;
+export declare function useCckEnv(): "default" | "test";
+export {};

package/lib/core/config-provider/config-provider.types.d.ts

@@ -0,0 +1,52 @@
+import { CStylesTransform } from './config-provider.context';
+import { CColorScheme, CThemeOverride } from './theme.types';
+export declare const CONFIG_KEY: unique symbol;
+export declare const THEME_KEY: unique symbol;
+export interface ConfigProviderProps {
+    /**
+     * @description Theme override object
+     */
+    theme?: CThemeOverride;
+    /**
+     * @description Default color scheme value used when `colorSchemeManager` cannot retrieve value from external storage
+     */
+    defaultColorScheme?: CColorScheme;
+    /**
+     * @description Forces color scheme value, if set, useTheme ignores `colorSchemeManager` and `defaultColorScheme`
+     */
+    forceColorScheme?: 'light' | 'dark';
+    /**
+     * @description CSS selector to which CSS variales should be added
+     */
+    cssVariablesSelector?: string;
+    /**
+     * @description Determines whether theme CSS variables should be added to given `cssVariablesSelector`
+     */
+    withCssVariables?: boolean;
+    /**
+     * @description Function to resolve root element to set `data-c-color-scheme` attribute
+     * @returns root element, must return undefined on server
+     */
+    getRootElement?: () => HTMLElement | undefined;
+    /**
+     * @description A prefix for components static classes (for example `${prefix}-text__root`)
+     */
+    classNamesPrefix?: string;
+    /**
+     * @description Determines whether components should have static classes, for example `c-button__root`
+     */
+    withStaticClasses?: boolean;
+    /**
+     * @description Determines whether global classes should be added with `<style />` tag. Global classes are required for `hiddenFrom`/`visibleFrom` and `lightHidden`/`darkHidden` props to work.
+     * @default true
+     */
+    withGlobalClasses?: boolean;
+    /**
+     * An object to transform `styles` and `sx` props into css classes, can be used with CSS-in-JS libraries
+     */
+    stylesTransform?: CStylesTransform;
+    /**
+     * @description Enviroment at which the useTheme is used, `'test'` environment disables all transitions and portals
+     */
+    env?: 'default' | 'test';
+}

package/lib/core/config-provider/convert-css-variables/convert-css-variables.d.ts

@@ -0,0 +1,7 @@
+import { CSSVariables } from './css-variables-object-to-string';
+export interface ConvertCSSVariablesInput {
+    variables: CSSVariables;
+    dark: CSSVariables;
+    light: CSSVariables;
+}
+export declare function convertCssVariables(input: ConvertCSSVariablesInput, selectorOverride?: string): string;

package/lib/core/config-provider/convert-css-variables/css-variables-object-to-string.d.ts

@@ -0,0 +1,3 @@
+import type { CssVariable } from '../../box';
+export type CSSVariables = Record<CssVariable, string>;
+export declare function cssVariablesObjectToString(variables: CSSVariables): string;

package/lib/core/config-provider/convert-css-variables/index.d.ts

@@ -0,0 +1,2 @@
+export { convertCssVariables } from './convert-css-variables';
+export type { ConvertCSSVariablesInput } from './convert-css-variables';

package/lib/core/config-provider/default-colors.d.ts

@@ -0,0 +1,2 @@
+import type { CThemeColors } from './theme.types';
+export declare const DEFAULT_COLORS: CThemeColors;

package/lib/core/config-provider/default-theme.d.ts

@@ -0,0 +1,2 @@
+import type { CTheme } from './theme.types';
+export declare const DEFAULT_THEME: CTheme;

package/lib/core/config-provider/index.d.ts

@@ -0,0 +1,9 @@
+import { SFCWithInstall } from '../utils';
+import ConfigProvider from './config-provider.vue';
+export * from './color-functions';
+export * from './config-provider.context';
+export * from './config-provider.types';
+export * from './default-theme';
+export * from './theme.types';
+export declare const CckConfigProvider: SFCWithInstall<typeof ConfigProvider>;
+export default CckConfigProvider;

package/lib/core/config-provider/theme.types.d.ts

@@ -0,0 +1,235 @@
+import { Properties } from 'csstype';
+import { PartialDeep } from 'type-fest';
+import { VariantColorsResolver } from './color-functions';
+export interface CTheme {
+    /**
+     * @description Controls focus ring styles. Supports the following options:
+     * @default 'auto'
+     * - `auto` - focus ring is displayed only when the user navigates with keyboard
+     * - `always` - focus ring is displayed when the user navigates with keyboard and mouse
+     * - `never` - focus ring is always hidden(not recommended)
+     */
+    focusRing: 'auto' | 'always' | 'never';
+    /**
+     * @description Rem units scale, change if you customize font-size of `html` element
+     * default value is `1` (for `100%`/`16px` font-size on `html`)
+     */
+    scale: number;
+    /**
+     * @description Determines whether `font-smoothing` property should be set on the body
+     * @default true
+     */
+    fontSmoothing: boolean;
+    /** @description White color */
+    white: string;
+    /** @description Black color */
+    black: string;
+    /** @description Object of colors, key is color name, value is an array of at least 10 strings (colors) */
+    colors: CThemeColors;
+    /**
+     * @description Index of theme.colors[color].
+     * Primary shade is used in all components to determine which color from theme.colors[color] should be used.
+     * Can be either a number (0-9) or an object to specify different color shades for light and dark color schemes.
+     * Default value `{ light: 6, dark: 8 }`
+     *
+     * @example
+     * { primaryShade: 6 } // shade 6 is used both for dark and light color schemes
+     * { primaryShade: { light: 6, dark: 7 } } // different shades for dark and light color schemes
+     */
+    primaryShade: CColorShade | CPrimaryShade;
+    /**
+     * @description Key of `theme.colors`, hex/rgb/hsl values are not supported.
+     * Determines which color will be used in all components by default.
+     * @default `blue`
+     */
+    primaryColor: string;
+    /**
+     * @description Function to resolve colors based on variant.
+     * Can be used to deeply customize how colors are applied to `Button`, `ActionIcon`, `ThemeIcon` and other components that use colors from theme.
+     */
+    variantColorResolver: VariantColorsResolver;
+    /**
+     * @description Determines whether text color must be changed based on the given `color` prop in filled variant
+     * For example, if you pass `color="blue.1"` to Button component, text color will be changed to `var(--c-color-black)`
+     * @default false
+     */
+    autoContrast: boolean;
+    /**
+     * @description Determines which luminance value is used to determine if text color should be light or dark.
+     * Used only if `theme.autoContrast` is set to `true`.
+     * @default 0.3
+     */
+    luminanceThreshold: number;
+    /**
+     * @description Font-family used in all components, system fonts by default
+     */
+    fontFamily: string;
+    /**
+     * @description Monospace font-family, used in code and other similar components, system fonts by default
+     */
+    fontFamilyMonospace: string;
+    /**
+     * @description Controls various styles of h1-h6 elements, used in Typography and Title components
+     */
+    headings: {
+        fontFamily: string;
+        fontWeight: string;
+        textWrap: 'wrap' | 'nowrap' | 'balance' | 'pretty' | 'stable';
+        sizes: {
+            h1: HeadingStyle;
+            h2: HeadingStyle;
+            h3: HeadingStyle;
+            h4: HeadingStyle;
+            h5: HeadingStyle;
+            h6: HeadingStyle;
+        };
+    };
+    /**
+     * @description Object of values that are used to set `border-radius` in all components that support it
+     */
+    radius: CRadiusValues;
+    /**
+     * @description Key of `theme.radius` or any valid CSS value.
+     * @default `border-radius` used by most components
+     */
+    defaultRadius: CRadius;
+    /**
+     * @description Object of values that are used to set various CSS properties that control spacing between elements
+     */
+    spacing: CSpacingValues;
+    /**
+     * @description Object of values that are used to control `font-size` property in all components
+     */
+    fontSizes: CFontSizesValues;
+    /**
+     * @description Object of values that are used to control `line-height` property in all components
+     */
+    lineHeights: CLineHeightValues;
+    /**
+     * @description Object of values that are used to control `font-weight` property in all components
+     */
+    fontWeights: CFontWeightsValues;
+    /**
+     * @description Object of values that are used to control breakpoints in all components,
+     * values are expected to be defined in em
+     */
+    breakpoints: CBreakpointsValues;
+    /**
+     * @description Object of values that are used to add `box-shadow` styles to components that support `shadow` prop
+     */
+    shadows: CShadowsValues;
+    /**
+     * @description Determines whether user OS settings to reduce motion should be respected.
+     * @default false
+     */
+    respectReducedMotion: boolean;
+    /**
+     * @description Determines which cursor type will be used for interactive elements
+     * - `default` - cursor that is used by native HTML elements, for example, `input[type="checkbox"]` has `cursor: default` styles
+     * - `pointer` - sets `cursor: pointer` on interactive elements that do not have these styles by default
+     */
+    cursorType: 'default' | 'pointer';
+    /**
+     * @description Default gradient configuration for components that support `variant="gradient"`
+     */
+    defaultGradient: CGradient;
+    /**
+     * @description Class added to the elements that have active styles, for example, `Button` and `ActionIcon`
+     */
+    activeClassName: string;
+    /**
+     * @description Class added to the elements that have focus styles, for example, `Button` or `ActionIcon`. Overrides `theme.focusRing` property.
+     */
+    focusClassName: string;
+    /**
+     * @description allows adding `classNames`, `styles` and `defaultProps` to any component
+     */
+    components: CThemeComponents;
+    /**
+     * @description Any other properties that you want to access with the theme objects
+     */
+    other: CThemeOther;
+}
+export type CColorScheme = 'light' | 'dark' | 'auto';
+export type CThemeOverride = PartialDeep<CTheme>;
+export type CStylesRecord = Record<string, Properties>;
+export interface CThemeComponent {
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    defaultProps?: any;
+}
+export type CThemeComponents = Record<string, CThemeComponent>;
+export interface HeadingStyle {
+    fontSize: string;
+    fontWeight?: string;
+    lineHeight: string;
+}
+export type CSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type DefaultCSize = CSize;
+export interface CThemeSizesOverride {
+}
+export type CBreakpoint = (CThemeSizesOverride extends {
+    breakpoints: Record<infer CustomBreakpoints, string>;
+} ? CustomBreakpoints : CSize) | (string & {});
+export type CBreakpointsValues = Record<CBreakpoint, string>;
+export type CFontSize = (CThemeSizesOverride extends {
+    fontSize: Record<infer CustomFontSizes, string>;
+} ? CustomFontSizes : CSize) | (string & {});
+export type CFontSizesValues = Record<CFontSize, string>;
+type _CRadius = (CThemeSizesOverride extends {
+    radius: Record<infer CustomRadius, string>;
+} ? CustomRadius : CSize) | (string & {});
+export type CRadius = _CRadius | number;
+export type CRadiusValues = Record<_CRadius, string>;
+type _CSpacing = (CThemeSizesOverride extends {
+    spacing: Record<infer CustomSpacing, string>;
+} ? CustomSpacing : CSize) | (string & {});
+export type CSpacing = _CSpacing | number;
+export type CSpacingValues = Record<CSpacing, string>;
+export type CShadow = (CThemeSizesOverride extends {
+    shadows: Record<infer CustomShadow, string>;
+} ? CustomShadow : CSize) | (string & {});
+export type CShadowsValues = Record<CShadow, string>;
+export type CLineHeight = (CThemeSizesOverride extends {
+    lineHeights: Record<infer CustomLineHeight, string>;
+} ? CustomLineHeight : CSize) | (string & {});
+export type CLineHeightValues = Record<CLineHeight, string>;
+export type CFontWeight = (CThemeSizesOverride extends {
+    fontWeights: Record<infer CustomFontWeight, string>;
+} ? CustomFontWeight : 'regular' | 'medium' | 'bold') | (string & {});
+export type CFontWeightsValues = Record<CFontWeight, string>;
+export interface CThemeOther {
+    [key: string]: any;
+}
+export interface CGradient {
+    from: string;
+    to: string;
+    deg?: number;
+}
+export type CColorsTuple = readonly [
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    ...string[]
+];
+export type CColorShade = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface CPrimaryShade {
+    light: CColorShade;
+    dark: CColorShade;
+}
+export type DefaultCColor = 'dark' | 'gray' | 'red' | 'pink' | 'grape' | 'violet' | 'indigo' | 'blue' | 'cyan' | 'green' | 'lime' | 'yellow' | 'orange' | 'teal' | (string & {});
+export interface CThemeColorsOverride {
+}
+export type CThemeColors = CThemeColorsOverride extends {
+    colors: Record<infer CustomColors, CColorsTuple>;
+} ? Record<CustomColors, CColorsTuple> : Record<DefaultCColor, CColorsTuple>;
+export type CColor = keyof CThemeColors;
+export {};

package/lib/core/factory/create-factory.d.ts

@@ -0,0 +1,4 @@
+import { FactoryPayload } from './factory';
+import { PolymorphicFactoryPayload } from './polymorphic-factory';
+export type Factory<Payload extends FactoryPayload> = Payload;
+export type PolymorphicFactory<Payload extends PolymorphicFactoryPayload> = Payload;

package/lib/core/factory/factory.d.ts

@@ -0,0 +1,11 @@
+export interface FactoryPayload {
+    props: Record<string, any>;
+    ctx?: any;
+    ref?: any;
+    stylesNames?: string;
+    vars?: any;
+    variant?: string;
+    staticComponents?: Record<string, any>;
+    compound?: boolean;
+    signature?: any;
+}

package/lib/core/factory/index.d.ts

@@ -0,0 +1,2 @@
+export type { Factory, PolymorphicFactory } from './create-factory';
+export type { FactoryPayload } from './factory';

package/lib/core/factory/polymorphic-factory.d.ts

@@ -0,0 +1,5 @@
+import { FactoryPayload } from './factory';
+export interface PolymorphicFactoryPayload extends FactoryPayload {
+    defaultComponent: any;
+    defaultRef: any;
+}

package/lib/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './box';
+export * from './config-provider';
+export * from './factory';
+export * from './responsive-style-manager';
+export * from './styles-api';
+export * from './utils';

package/lib/core/responsive-style-manager/css-object-to-string/css-object-to-string.d.ts

@@ -0,0 +1,2 @@
+import { Properties } from 'csstype';
+export declare function cssObjectToString(css: Properties): string;

package/lib/core/responsive-style-manager/hash-styles.d.ts

@@ -0,0 +1,3 @@
+import { Properties } from 'csstype';
+import { StylesMediaQuery } from './styles-to-string/styles-to-string';
+export declare function hashStyleProps(styles: Properties | undefined, media: StylesMediaQuery[] | undefined): string;

package/lib/core/responsive-style-manager/index.d.ts

@@ -0,0 +1,5 @@
+export { responsiveStyleManager } from './responsive-style-manager';
+export { hashStyleProps } from './hash-styles';
+export { normalizeNumberLikeStringProp } from './normalize-number-like-string-prop/normalize-number-like-string-prop';
+export { stylesToString } from './styles-to-string/styles-to-string';
+export type { StylesInput, StylesMediaQuery } from './styles-to-string/styles-to-string';

package/lib/core/responsive-style-manager/normalize-number-like-string-prop/normalize-number-like-string-prop.d.ts

@@ -0,0 +1,2 @@
+import { NumberLikeString, StyleProp } from '../../box';
+export declare function normalizeNumberLikeStringProp(prop: StyleProp<NumberLikeString | undefined>): StyleProp<number> | undefined;

package/lib/core/responsive-style-manager/responsive-style-manager.d.ts

@@ -0,0 +1,12 @@
+export interface StyleManagerEntry {
+    refCount: number;
+    styleEl: HTMLStyleElement;
+    cssText: string;
+}
+declare class ResponsiveStyleManager {
+    private styleMap;
+    register(cssText: string, key?: string): string;
+    unregister(styleKey: string): void;
+}
+export declare const responsiveStyleManager: ResponsiveStyleManager;
+export {};

package/lib/core/responsive-style-manager/styles-to-string/styles-to-string.d.ts

@@ -0,0 +1,12 @@
+import { Properties } from 'csstype';
+export interface StylesMediaQuery {
+    query: string;
+    styles: Properties;
+}
+export interface StylesInput {
+    selector: string;
+    styles?: Properties;
+    media?: StylesMediaQuery[];
+    container?: StylesMediaQuery[];
+}
+export declare function stylesToString({ container, media, selector, styles }: StylesInput): string;

package/lib/core/styles-api/create-vars-resolver/create-vars-resolver.d.ts

@@ -0,0 +1,10 @@
+import { CTheme, CssVariable, FactoryPayload } from '../..';
+export type TransformVars<V> = {
+    [Key in keyof V]: V[Key] extends CssVariable ? Record<V[Key], string | undefined> : never;
+};
+export type PartialTransformVars<V> = {
+    [Key in keyof V]: V[Key] extends CssVariable ? Partial<Record<V[Key], string | undefined>> : never;
+};
+export type VarsResolver<Payload extends FactoryPayload> = (theme: CTheme, props: Payload['props'], ctx: Payload['ctx']) => TransformVars<Payload['vars']>;
+export type PartialVarsResolver<Payload extends FactoryPayload> = (theme: CTheme, props: Payload['props'], ctx: Payload['ctx']) => PartialTransformVars<Payload['vars']>;
+export declare function createVarsResolver<Payload extends FactoryPayload>(resolver: VarsResolver<Payload>): VarsResolver<Payload>;

package/lib/core/styles-api/index.d.ts

@@ -0,0 +1,7 @@
+export { createVarsResolver } from './create-vars-resolver/create-vars-resolver';
+export { resolveClassNames } from './use-styles/get-class-name/resolve-class-names/resolve-class-names';
+export { resolveStyles } from './use-styles/get-style/resolve-styles/resolve-styles';
+export { FOCUS_CLASS_NAMES } from './use-styles/get-class-name/get-global-class-names/get-global-class-names';
+export * from './styles-api.types';
+export * from './use-styles/use-styles';
+export type { VarsResolver, PartialVarsResolver, TransformVars, PartialTransformVars } from './create-vars-resolver/create-vars-resolver';

package/lib/core/styles-api/styles-api.types.d.ts

@@ -0,0 +1,40 @@
+import { Properties } from 'csstype';
+import { CStyleProp } from '../box';
+import type { FactoryPayload } from '../factory';
+import type { CTheme } from '../config-provider';
+import { PartialVarsResolver } from './create-vars-resolver/create-vars-resolver';
+export type Styles<Payload extends FactoryPayload> = StylesApiRecord<Payload, Properties>;
+export type ClassNames<Payload extends FactoryPayload> = StylesApiRecord<Payload, string>;
+export type ClassNamesArray<Payload extends FactoryPayload> = (StylesApiRecord<Payload, string> | undefined)[];
+export type Attributes<Payload extends FactoryPayload> = Payload['stylesNames'] extends string ? Payload['compound'] extends true ? never : {
+    [K in Payload['stylesNames']]?: Record<string, any>;
+} : never;
+export type StylesRecord<StylesNames extends string, Payload> = Partial<Record<StylesNames, Payload>>;
+export interface GetStylesApiOptions {
+    className?: string;
+    style?: CStyleProp;
+    focusable?: boolean;
+    active?: boolean;
+    classNames?: ClassNames<{
+        props: any;
+        stylesNames: string;
+    }>;
+    styles?: Styles<{
+        props: any;
+        stylesNames: string;
+    }>;
+    variant?: string;
+    props?: Record<string, any>;
+    withStaticClass?: boolean;
+}
+export type StylesApiRecord<Payload extends FactoryPayload, DataType> = Payload['compound'] extends true ? Payload['stylesNames'] extends string ? StylesRecord<Payload['stylesNames'], DataType> : never : Payload['stylesNames'] extends string ? StylesRecord<Payload['stylesNames'], DataType> | ((theme: CTheme, props: Payload['props'], ctx: Payload['ctx']) => StylesRecord<Payload['stylesNames'], DataType>) : never;
+export interface StylesApiProps<Payload extends FactoryPayload> {
+    unstyled?: boolean;
+    variant?: Payload['variant'] extends string ? Payload['variant'] | (string & {}) : string;
+    classNames?: ClassNames<Payload>;
+    styles?: Styles<Payload>;
+    vars?: PartialVarsResolver<Payload>;
+    attributes?: Attributes<Payload>;
+}
+export interface CompoundStylesApiProps<Payload extends FactoryPayload> extends Omit<StylesApiProps<Payload>, 'unstyled' | 'attributes'> {
+}

package/lib/core/styles-api/use-styles/get-class-name/get-class-name.d.ts

@@ -0,0 +1,24 @@
+import { CTheme } from '../../../config-provider';
+import { GetStylesApiOptions } from '../../styles-api.types';
+type __ClassNames = undefined | Partial<Record<string, string>> | ((theme: CTheme, props: Record<string, any>, ctx: Record<string, any> | undefined) => Partial<Record<string, string>>);
+export type _ClassNames = __ClassNames | __ClassNames[];
+export interface GetClassNameOptions {
+    theme: CTheme;
+    options: GetStylesApiOptions | undefined;
+    themeName: string[];
+    selector: string;
+    classNamesPrefix: string;
+    resolvedClassNames: Partial<Record<string, string>>;
+    resolvedThemeClassNames: Partial<Record<string, string>>[];
+    classes: Record<string, string>;
+    unstyled: boolean | undefined;
+    className: string | undefined;
+    rootSelector: string;
+    props: Record<string, any>;
+    stylesCtx?: Record<string, any> | undefined;
+    withStaticClasses?: boolean;
+    headless?: boolean;
+    transformedStyles?: Record<string, string>[];
+}
+export declare function getClassName({ theme, options, themeName, selector, classNamesPrefix, resolvedClassNames, resolvedThemeClassNames, classes, unstyled, className, rootSelector, props, stylesCtx, withStaticClasses, headless, transformedStyles, }: GetClassNameOptions): string;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-global-class-names/get-global-class-names.d.ts

@@ -0,0 +1,17 @@
+import { CTheme } from '../../../../config-provider';
+import { GetStylesApiOptions } from '../../../styles-api.types';
+interface GetGlobalClassNamesOptions {
+    theme: CTheme;
+    unstyled: boolean | undefined;
+    options: GetStylesApiOptions | undefined;
+}
+export declare const FOCUS_CLASS_NAMES: {
+    readonly always: "c-focus-always";
+    readonly auto: "c-focus-auto";
+    readonly never: "c-focus-never";
+};
+/**
+ * @returns classes that are defined globally (focus and active styles) based on options
+ */
+export declare function getGlobalClassNames({ theme, options, unstyled, }: GetGlobalClassNamesOptions): string;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-options-class-names/get-options-class-names.d.ts

@@ -0,0 +1,8 @@
+import { GetStylesApiOptions } from '../../../styles-api.types';
+import { ResolveClassNamesInput } from '../resolve-class-names/resolve-class-names';
+interface GetOptionsClassNamesInput extends Omit<ResolveClassNamesInput, 'classNames'> {
+    selector: string;
+    options: GetStylesApiOptions | undefined;
+}
+export declare function getOptionsClassNames({ selector, stylesCtx, options, props, theme }: GetOptionsClassNamesInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-resolved-class-names/get-resolved-class-names.d.ts

@@ -0,0 +1,6 @@
+import { ResolveClassNamesInput } from '../resolve-class-names/resolve-class-names';
+interface GetResolvedClassNamesOptions extends ResolveClassNamesInput {
+    selector: string;
+}
+export declare function getResolvedClassNames({ selector, stylesCtx, theme, classNames, props }: GetResolvedClassNamesOptions): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-root-class-name/get-root-class-name.d.ts

@@ -0,0 +1,7 @@
+interface GetRootClassNameInput {
+    rootSelector: string;
+    selector: string;
+    className: string | undefined;
+}
+export declare function getRootClassName({ rootSelector, selector, className }: GetRootClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-selector-class-name/get-selector-class-name.d.ts

@@ -0,0 +1,7 @@
+interface GetSelectorClassNameInput {
+    selector: string;
+    classes: Record<string, string>;
+    unstyled: boolean | undefined;
+}
+export declare function getSelectorClassName({ selector, classes, unstyled }: GetSelectorClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-static-class-names/get-static-class-names.d.ts

@@ -0,0 +1,8 @@
+interface GetStaticClassNamesInput {
+    themeName: string[];
+    selector: string;
+    classNamesPrefix: string;
+    withStaticClass?: boolean;
+}
+export declare function getStaticClassNames({ themeName, classNamesPrefix, selector, withStaticClass }: GetStaticClassNamesInput): string[];
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-variant-class-name/get-variant-class-name.d.ts

@@ -0,0 +1,12 @@
+import { GetStylesApiOptions } from '../../../styles-api.types';
+interface GetVariantClassNameInput {
+    options: GetStylesApiOptions | undefined;
+    classes: Record<string, string>;
+    selector: string;
+    unstyled: boolean | undefined;
+}
+/**
+ * @returns Variant className, variant is always separated from selector with `--`, for example, `tab--default`
+ */
+export declare function getVariantClassName({ options, classes, selector, unstyled }: GetVariantClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/resolve-class-names/resolve-class-names.d.ts

@@ -0,0 +1,9 @@
+import { CTheme } from '../../../../config-provider';
+import { _ClassNames } from '../get-class-name';
+export interface ResolveClassNamesInput {
+    theme: CTheme;
+    classNames: _ClassNames;
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+}
+export declare function resolveClassNames({ theme, classNames, props, stylesCtx }: ResolveClassNamesInput): Partial<Record<string, string>>;