@cck-ui/core 0.2.0

package/lib/components/loader/index.d.ts

@@ -0,0 +1,7 @@
+import { SFCWithInstall } from '../../core';
+import Loader from './loader.vue';
+import { CLoadersRecord } from './loader.types.js';
+export declare const CDefaultLoaders: CLoadersRecord;
+export declare const CLoader: SFCWithInstall<typeof Loader>;
+export default CLoader;
+export * from './loader.types';

package/lib/components/loader/loader.types.d.ts

@@ -0,0 +1,46 @@
+import { Component } from 'vue';
+import { BoxProps, CColor, CSize, ElementProps, Factory, StylesApiProps } from '../../core';
+import { CDefaultLoaders } from '.';
+export type CLoaderComponent = Component<Record<string, any> & {
+    ref?: any;
+}>;
+/**
+ * Registry of loader components keyed by name.
+ * Supports built-in 'bars' | 'dots' | 'oval' and any custom string.
+ */
+export type CLoadersRecord = Partial<Record<'bars' | 'dots' | 'oval' | (string & {}), CLoaderComponent>>;
+export type CLoaderType = keyof CLoadersRecord;
+export type LoaderStylesNames = 'root';
+export type LoaderCssVariables = {
+    root: '--loader-size' | '--loader-color';
+};
+export type LoaderFactory = Factory<{
+    props: LoaderProps;
+    ref: SVGSVGElement;
+    stylesNames: LoaderStylesNames;
+    vars: LoaderCssVariables;
+    staticComponents: {
+        defaultLoaders: typeof CDefaultLoaders;
+    };
+}>;
+export interface LoaderProps extends BoxProps, StylesApiProps<LoaderFactory>, ElementProps<'svg', 'display' | 'opacity'> {
+    /**
+     * @description Key of `theme.colors` or any valid CSS color
+     * @default theme.primaryColor
+     */
+    color?: CColor;
+    /**
+     * @description Object of loaders components, can be customized via default props or inline.
+     */
+    loaders?: CLoadersRecord;
+    /**
+     * @description Controls `width` and `height` of the loader. `Loader` has predefined `xs`-`xl` values. Numbers are converted to rem.
+     * @default 'md'
+     */
+    size?: CSize | (string & {}) | number;
+    /**
+     * @description Loader type, key of `loaders` prop
+     * @default 'oval'
+     */
+    type?: CLoaderType;
+}

package/lib/components/loader/use-loader.d.ts

@@ -0,0 +1,3 @@
+export declare const useLoader: () => {
+    _ref: import("vue").Ref<HTMLElement | SVGElement | undefined, HTMLElement | SVGElement | undefined>;
+};

package/lib/components/simple-grid/index.d.ts

@@ -0,0 +1,5 @@
+import { SFCWithInstall } from '../../core';
+import SimpleGrid from './simple-grid.vue';
+export declare const CSimpleGrid: SFCWithInstall<typeof SimpleGrid>;
+export default CSimpleGrid;
+export * from './simple-grid.types';

package/lib/components/simple-grid/simple-grid-custom.d.ts

@@ -0,0 +1,9 @@
+import { SimpleGridProps } from './simple-grid.types';
+interface SimpleGridVariablesProps extends SimpleGridProps {
+    selector: string;
+}
+export declare function useSimpleGridStyle(props: SimpleGridVariablesProps): import("vue").ComputedRef<{
+    attrs: Record<string, string | undefined>;
+    queryStylesString: string;
+}>;
+export {};

package/lib/components/simple-grid/simple-grid.types.d.ts

@@ -0,0 +1,42 @@
+import { BoxProps, CSpacing, ElementProps, Factory, NumberLikeString, StyleProp, StylesApiProps } from '../../core';
+export type SimpleGridStylesNames = 'root' | 'container';
+export interface SimpleGridProps extends BoxProps, StylesApiProps<SimpleGridFactory>, /* @vue-ignore */ ElementProps<'div'> {
+    /**
+     * @description Number of columns
+     * @default 1
+     */
+    cols?: StyleProp<NumberLikeString>;
+    /**
+     * @description Spacing between columns
+     * @default 'md'
+     */
+    spacing?: StyleProp<CSpacing>;
+    /**
+     * @description Spacing between rows. When not set, falls back to spacing value
+     * @default undefined
+     */
+    verticalSpacing?: StyleProp<CSpacing>;
+    /**
+     * @description Determines type of queries that are used for responsive styles
+     * @default 'media'
+     */
+    type?: 'media' | 'container';
+    /**
+     * @description Minimum column width when using auto-fit/auto-fill. When set, cols prop is ignored
+     */
+    minColWidth?: string | NumberLikeString;
+    /**
+     * @description Grid repeat type when minColWidth is set
+     * @default 'auto-fill'
+     */
+    autoFlow?: 'auto-fit' | 'auto-fill';
+    /**
+     * @description Sets the size of implicitly created grid rows
+     */
+    autoRows?: string;
+}
+export type SimpleGridFactory = Factory<{
+    props: SimpleGridProps;
+    ref: HTMLDivElement;
+    stylesNames: SimpleGridStylesNames;
+}>;

package/lib/components/text/index.d.ts

@@ -0,0 +1,5 @@
+import { SFCWithInstall } from '../../core';
+import Text from './text.vue';
+export declare const CText: SFCWithInstall<typeof Text>;
+export default CText;
+export * from './text.types';

package/lib/components/text/text.types.d.ts

@@ -0,0 +1,54 @@
+import { BoxProps, CFontSize, CGradient, CLineHeight, PolymorphicFactory, StylesApiProps } from '../../core';
+export type TextTruncate = 'end' | 'start' | boolean;
+export type TextStylesNames = 'root';
+export type TextVariant = 'text' | 'gradient';
+export type TextCssVariables = {
+    root: '--text-gradient' | '--text-line-clamp' | '--text-fz' | '--text-lh' | '--text-text-wrap';
+};
+export type TextFactory = PolymorphicFactory<{
+    props: TextProps;
+    defaultComponent: 'p';
+    defaultRef: HTMLParagraphElement;
+    stylesNames: TextStylesNames;
+    vars: TextCssVariables;
+    variant: TextVariant;
+}>;
+export interface TextProps extends BoxProps, StylesApiProps<TextFactory> {
+    __staticSelector?: string;
+    /**
+     * @description Controls `font-size` and `line-height`
+     * @default 'md'
+     */
+    size?: CFontSize | CLineHeight;
+    /**
+     * @description Number of lines after which Text will be truncated
+     */
+    lineClamp?: number;
+    /**
+     * @description Side on which Text must be truncated, if `true`, text is truncated from the start
+     */
+    truncate?: TextTruncate;
+    /**
+     * @description Sets `line-height` to 1 for centering
+     * @default false
+     */
+    inline?: boolean;
+    /**
+     * @description Determines whether font properties should be inherited from the parent
+     * @default false
+     */
+    inherit?: boolean;
+    /**
+     * @description Gradient configuration, ignored when `variant` is not `gradient`
+     * @default theme.defaultGradient
+     */
+    gradient?: CGradient;
+    /**
+     * Shorthand for `tag="span"`
+     */
+    span?: boolean;
+    /**
+     * Controls `text-wrap` CSS property
+     */
+    textWrap?: 'wrap' | 'nowrap' | 'balance' | 'pretty' | 'stable';
+}

package/lib/components/unstyled-button/index.d.ts

@@ -0,0 +1,5 @@
+import { SFCWithInstall } from '../../core';
+import _UnstyledButton from './unstyled-button.vue';
+export declare const UnstyledButton: SFCWithInstall<typeof _UnstyledButton>;
+export default UnstyledButton;
+export * from './unstyled-button.types';

package/lib/components/unstyled-button/unstyled-button.types.d.ts

@@ -0,0 +1,15 @@
+import { BoxComponentProps, PolymorphicFactory, StylesApiProps } from '../../core';
+export type UnstyledButtonStylesNames = 'root';
+export type UnstyledButtonFactory = PolymorphicFactory<{
+    props: UnstyledButtonProps;
+    stylesNames: UnstyledButtonStylesNames;
+    defaultComponent: 'button';
+    defaultRef: HTMLButtonElement;
+}>;
+interface _UnstyledButtonProps extends Omit<BoxComponentProps, 'vars' | 'variant'>, StylesApiProps<UnstyledButtonFactory> {
+    __staticSelector?: string;
+}
+export type UnstyledButtonProps = _UnstyledButtonProps & {
+    tag?: any;
+};
+export {};

package/lib/core/box/box.types.d.ts

@@ -0,0 +1,72 @@
+import { Properties } from 'csstype';
+import { CStyleProps } from './style-props/style-props.types';
+import { CBreakpoint, CTheme } from '../config-provider/theme.types';
+import { JSX } from 'vue/jsx-runtime';
+export type NumberLikeString = number | `${number}`;
+export interface CSSProperties extends Properties {
+    [key: string]: any;
+}
+type CStyle = CSSProperties | ((theme: CTheme) => CSSProperties);
+export type CStyleProp = CStyle | CStyle[] | CStyleProp[] | undefined;
+export type CssVariable = `--${string}`;
+export type CssVariables<Variable extends string = CssVariable> = Partial<Record<Variable, string>>;
+export type CssVars<Variable extends string = CssVariable> = CssVariables<Variable> | ((theme: CTheme) => CssVariables<Variable>) | CssVars<Variable>[];
+export type CssVarsProp<Variable extends string = CssVariable> = CssVars<Variable> | CssVars<Variable>[];
+export type Mod = Record<string, any> | string;
+export type BoxMod = Mod | Mod[] | BoxMod[];
+export interface BoxProps extends CStyleProps {
+    /**
+     * @description Class added to component root element, if applicable
+     */
+    className?: string;
+    /**
+     * @description Inline style added to component root element, can subscribe to theme defined on provider
+     */
+    style?: CStyleProp;
+    /**
+     * @description CSS variables defined on component root element
+     */
+    __vars?: CssVarsProp;
+    /**
+     * @description `size` property passed down the HTML element
+     */
+    __size?: string;
+    /**
+     * @description Breakpoint above which the component is hidden with `display: none`
+     */
+    hiddenFrom?: CBreakpoint;
+    /**
+     * @description Breakpoint below which the component is hidden with `display: none`
+     */
+    visibleFrom?: CBreakpoint;
+    /**
+     * @description Determines whether component should be hidden in light color scheme with `display: none`
+     */
+    lightHidden?: boolean;
+    /**
+     * @description Determines whether component should be hidden in dark color scheme with `display: none`
+     */
+    darkHidden?: boolean;
+    /**
+     * @description Element modifiers transformed into `data-` attributes, for example, `{ 'data-size': 'xl' }`, falsy values are removed
+     */
+    mod?: BoxMod;
+}
+/**
+ * @description Extracts props from a Vue component or HTML element, omitting specified keys.
+ *
+ * @example
+ * type SvgProps = ElementProps<'svg', 'style' | 'display'>
+ */
+export type ElementProps<Tag extends keyof JSX.IntrinsicElements, PropsToOmit extends string = never> = Omit<JSX.IntrinsicElements[Tag], 'style' | PropsToOmit>;
+export interface BoxComponentProps extends BoxProps {
+    /**
+     * @description Size passed from parent component, sets `data-size` if value is not number like
+     */
+    size?: string | number;
+    /**
+     * @description Variant passed from parent component, sets `data-variant`
+     */
+    variant?: string;
+}
+export {};

package/lib/core/box/get-box-mod/get-box-mod.d.ts

@@ -0,0 +1,2 @@
+export declare function getMod(props: Record<string, any>): Record<string, any>;
+export declare function getBoxMod(mod?: any): Record<string, any> | null;

package/lib/core/box/get-box-style/get-box-style.d.ts

@@ -0,0 +1,11 @@
+import { Properties } from 'csstype';
+import { CStyleProp, CssVarsProp } from '../box.types';
+import { CTheme } from '../../config-provider';
+interface GetBoxStyleOptions {
+    theme: CTheme;
+    styleProps: Properties;
+    style?: CStyleProp;
+    vars?: CssVarsProp;
+}
+export declare function getBoxStyle({ style, styleProps, theme, vars }: GetBoxStyleOptions): Properties;
+export {};

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

@@ -0,0 +1,7 @@
+import { SFCWithInstall } from '../utils';
+import Box from './box.vue';
+export * from './style-props';
+export * from './box.types';
+export { useRandomClassName } from './use-random-classname/use-random-classname';
+export declare const CBox: SFCWithInstall<typeof Box>;
+export default CBox;

package/lib/core/box/style-props/extract-style-props/extract-style-props.d.ts

@@ -0,0 +1,7 @@
+import { CStyleProps } from '../style-props.types';
+export declare function extractStyleProps<T extends Record<string, any>>(others: CStyleProps & T): {
+    styleProps: CStyleProps & {
+        sx?: any;
+    };
+    rest: T;
+};

package/lib/core/box/style-props/index.d.ts

@@ -0,0 +1,5 @@
+export * from './style-props.types';
+export { extractStyleProps } from './extract-style-props/extract-style-props';
+export { parseStyleProps } from './parse-style-props/parse-style-props';
+export { STYLE_PROPS_DATA } from './style-props-data';
+export type { SystemPropData } from './style-props-data';

package/lib/core/box/style-props/parse-style-props/parse-style-props.d.ts

@@ -0,0 +1,17 @@
+import { Properties } from 'csstype';
+import { CTheme } from '../../../config-provider';
+import { SystemPropData } from '../style-props-data';
+import { StyleProp } from '../style-props.types';
+import { SortMediaQueriesResult } from './sort-media-queries';
+export interface ParseStylePropsOptions {
+    data: Record<string, SystemPropData>;
+    styleProps: Record<string, StyleProp<any>>;
+    theme: CTheme;
+}
+export interface ParseStylePropsResult {
+    hasResponsiveStyles: boolean;
+    inlineStyles: Properties;
+    styles: Properties;
+    media: Record<string, Properties>;
+}
+export declare function parseStyleProps({ data, styleProps, theme }: ParseStylePropsOptions): SortMediaQueriesResult;

package/lib/core/box/style-props/parse-style-props/sort-media-queries.d.ts

@@ -0,0 +1,6 @@
+import { StylesMediaQuery } from '../../../responsive-style-manager';
+import { ParseStylePropsResult } from './parse-style-props';
+export interface SortMediaQueriesResult extends Omit<ParseStylePropsResult, 'media'> {
+    media: StylesMediaQuery[];
+}
+export declare function sortMediaQueries({ media, ...props }: ParseStylePropsResult): SortMediaQueriesResult;

package/lib/core/box/style-props/resolvers/border-resolver/border-resolver.d.ts

@@ -0,0 +1,2 @@
+import { CTheme } from '../../../../config-provider';
+export declare function borderResolver(value: unknown, theme: CTheme): unknown;

package/lib/core/box/style-props/resolvers/color-resolver/color-resolver.d.ts

@@ -0,0 +1,3 @@
+import { CTheme } from '../../../../config-provider';
+export declare function colorResolver(color: unknown, theme: CTheme): string;
+export declare function textColorResolver(color: unknown, theme: CTheme): string;

package/lib/core/box/style-props/resolvers/font-family-resolver/font-family-resolver.d.ts

@@ -0,0 +1 @@
+export declare function fontFamilyResolver(fontFamily: unknown): unknown;

package/lib/core/box/style-props/resolvers/font-size-resolver/font-size-resolver.d.ts

@@ -0,0 +1,2 @@
+import { CTheme } from '../../../../config-provider';
+export declare function fontSizeResolver(value: unknown, theme: CTheme): unknown;

package/lib/core/box/style-props/resolvers/identity-resolver/identity-resolver.d.ts

@@ -0,0 +1 @@
+export declare function identityResolver(value: unknown): unknown;

package/lib/core/box/style-props/resolvers/index.d.ts

@@ -0,0 +1,22 @@
+import { borderResolver } from './border-resolver/border-resolver';
+import { colorResolver, textColorResolver } from './color-resolver/color-resolver';
+import { fontFamilyResolver } from './font-family-resolver/font-family-resolver';
+import { fontSizeResolver } from './font-size-resolver/font-size-resolver';
+import { identityResolver } from './identity-resolver/identity-resolver';
+import { lineHeightResolver } from './line-height-resolver/line-height-resolver';
+import { radiusResolver } from './radius-resolver/radius-resolver';
+import { sizeResolver } from './size-resolver/size-resolver';
+import { spacingResolver } from './spacing-resolver/spacing-resolver';
+export declare const resolvers: {
+    border: typeof borderResolver;
+    color: typeof colorResolver;
+    fontFamily: typeof fontFamilyResolver;
+    fontSize: typeof fontSizeResolver;
+    identity: typeof identityResolver;
+    lineHeight: typeof lineHeightResolver;
+    radius: typeof radiusResolver;
+    size: typeof sizeResolver;
+    spacing: typeof spacingResolver;
+    textColor: typeof textColorResolver;
+};
+export type StylePropType = keyof typeof resolvers;

package/lib/core/box/style-props/resolvers/line-height-resolver/line-height-resolver.d.ts

@@ -0,0 +1,2 @@
+import { CTheme } from '../../../../config-provider';
+export declare function lineHeightResolver(value: unknown, theme: CTheme): unknown;

package/lib/core/box/style-props/resolvers/radius-resolver/radius-resolver.d.ts

@@ -0,0 +1,2 @@
+import { CTheme } from '../../../../config-provider';
+export declare function radiusResolver(value: unknown, theme: CTheme): unknown;

package/lib/core/box/style-props/resolvers/size-resolver/size-resolver.d.ts

@@ -0,0 +1 @@
+export declare function sizeResolver(value: unknown): unknown;

package/lib/core/box/style-props/resolvers/spacing-resolver/spacing-resolver.d.ts

@@ -0,0 +1,2 @@
+import { CTheme } from '../../../../';
+export declare function spacingResolver(value: unknown, theme: CTheme): unknown;

package/lib/core/box/style-props/style-props-data.d.ts

@@ -0,0 +1,7 @@
+import { StylePropType } from './resolvers';
+import { CStyleProps } from './style-props.types';
+export interface SystemPropData {
+    type: StylePropType;
+    property: string | string[];
+}
+export declare const STYLE_PROPS_DATA: Record<keyof CStyleProps, SystemPropData>;

package/lib/core/box/style-props/style-props.types.d.ts

@@ -0,0 +1,106 @@
+import { Property } from 'csstype';
+import { CBreakpoint, CColor, CFontSize, CLineHeight, CSpacing } from '../../config-provider';
+export type StyleProp<Value> = Value | Partial<Record<CBreakpoint | (string & {}), Value>>;
+export interface CStyleProps {
+    /** Margin */
+    m?: StyleProp<CSpacing>;
+    /** MarginBlock */
+    my?: StyleProp<CSpacing>;
+    /** MarginInline */
+    mx?: StyleProp<CSpacing>;
+    /** MarginTop */
+    mt?: StyleProp<CSpacing>;
+    /** MarginBottom */
+    mb?: StyleProp<CSpacing>;
+    /** MarginInlineStart */
+    ms?: StyleProp<CSpacing>;
+    /** MarginInlineEnd */
+    me?: StyleProp<CSpacing>;
+    /** MarginInlineStart */
+    mis?: StyleProp<CSpacing>;
+    /** MarginInlineEnd */
+    mie?: StyleProp<CSpacing>;
+    /** MarginLeft */
+    ml?: StyleProp<CSpacing>;
+    /** MarginRight */
+    mr?: StyleProp<CSpacing>;
+    /** Padding */
+    p?: StyleProp<CSpacing>;
+    /** PaddingBlock */
+    py?: StyleProp<CSpacing>;
+    /** PaddingInline */
+    px?: StyleProp<CSpacing>;
+    /** PaddingTop */
+    pt?: StyleProp<CSpacing>;
+    /** PaddingBottom */
+    pb?: StyleProp<CSpacing>;
+    /** PaddingInlineStart */
+    ps?: StyleProp<CSpacing>;
+    /** PaddingInlineEnd */
+    pe?: StyleProp<CSpacing>;
+    /** PaddingInlineStart */
+    pis?: StyleProp<CSpacing>;
+    /** PaddingInlineEnd */
+    pie?: StyleProp<CSpacing>;
+    /** PaddingLeft */
+    pl?: StyleProp<CSpacing>;
+    /** PaddingRight */
+    pr?: StyleProp<CSpacing>;
+    /** Border */
+    bd?: StyleProp<Property.Border>;
+    /** BorderRadius */
+    bdrs?: StyleProp<CSpacing>;
+    /** Background */
+    bg?: StyleProp<CColor>;
+    /** Color */
+    c?: StyleProp<CColor>;
+    /** Opacity */
+    opacity?: StyleProp<Property.Opacity>;
+    /** FontFamily */
+    ff?: StyleProp<'monospace' | 'text' | 'heading' | (string & {})>;
+    /** FontSize */
+    fz?: StyleProp<CFontSize | `h${1 | 2 | 3 | 4 | 5 | 6}` | number | (string & {})>;
+    /** FontWeight */
+    fw?: StyleProp<Property.FontWeight>;
+    /** LetterSpacing */
+    lts?: StyleProp<Property.LetterSpacing>;
+    /** TextAlign */
+    ta?: StyleProp<Property.TextAlign>;
+    /** LineHeight */
+    lh?: StyleProp<CLineHeight | `h${1 | 2 | 3 | 4 | 5 | 6}` | number | (string & {})>;
+    /** FontStyle */
+    fs?: StyleProp<Property.FontSize>;
+    /** TextTransform */
+    tt?: StyleProp<Property.TextTransform>;
+    /** TextDecoration */
+    td?: StyleProp<Property.TextDecoration>;
+    /** Width */
+    w?: StyleProp<Property.Width>;
+    /** MinWidth */
+    miw?: StyleProp<Property.MinWidth>;
+    /** MaxWidth */
+    maw?: StyleProp<Property.MaxWidth>;
+    /** Height */
+    h?: StyleProp<Property.Height>;
+    /** MinHeight */
+    mih?: StyleProp<Property.MinHeight>;
+    /** MaxHeight */
+    mah?: StyleProp<Property.MaxHeight>;
+    /** BackgroundSize */
+    bgsz?: StyleProp<Property.BackgroundSize>;
+    /** BackgroundPosition */
+    bgp?: StyleProp<Property.BackgroundPosition>;
+    /** BackgroundRepeat */
+    bgr?: StyleProp<Property.BackgroundRepeat>;
+    /** BackgroundAttachment */
+    bga?: StyleProp<Property.BackgroundAttachment>;
+    /** Position */
+    pos?: StyleProp<Property.Position>;
+    top?: StyleProp<Property.Top>;
+    left?: StyleProp<Property.Left>;
+    bottom?: StyleProp<Property.Bottom>;
+    right?: StyleProp<Property.Right>;
+    inset?: StyleProp<Property.Inset>;
+    display?: StyleProp<Property.Display>;
+    flex?: StyleProp<Property.Flex>;
+}

package/lib/core/box/use-random-classname/use-random-classname.d.ts

@@ -0,0 +1 @@
+export declare function useRandomClassName(): string;

package/lib/core/config-provider/cck-css-variables/default-css-variables-resolver.d.ts

@@ -0,0 +1,4 @@
+import { ConvertCSSVariablesInput } from '../convert-css-variables';
+import { CTheme } from '../theme.types';
+export type CSSVariablesResolver = (theme: CTheme) => ConvertCSSVariablesInput;
+export declare const defaultCssVariablesResolver: CSSVariablesResolver;

package/lib/core/config-provider/cck-css-variables/get-css-color-variables.d.ts

@@ -0,0 +1,12 @@
+import { CColor, CTheme } from '../theme.types';
+interface GetColorVariablesInput {
+    theme: CTheme;
+    color: CColor;
+    colorScheme: 'light' | 'dark';
+    name?: string;
+    withColorValues?: boolean;
+}
+export declare function getCSSColorVariables({ theme, color, colorScheme, name, withColorValues, }: GetColorVariablesInput): {
+    [x: string]: string;
+};
+export {};

package/lib/core/config-provider/cck-css-variables/virtual-color/virtual-color.d.ts

@@ -0,0 +1,15 @@
+import { CColor, CColorsTuple } from '../../theme.types';
+interface VirtualColorInput {
+    dark: CColor;
+    light: CColor;
+    name: string;
+}
+type VirtualColor = CColorsTuple & {
+    'c-virtual-color': true;
+    name: string;
+    dark: CColor;
+    light: CColor;
+};
+export declare function VirtualColor(input: VirtualColorInput): CColorsTuple;
+export declare function isVirtualColor(value: unknown): value is VirtualColor;
+export {};

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

@@ -0,0 +1,2 @@
+import { CColorsTuple } from '../../theme.types';
+export declare function colorsTuple(input: string | string[]): CColorsTuple;

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

@@ -0,0 +1 @@
+export declare function darken(color: string, alpha: number): string;

package/lib/core/config-provider/color-functions/default-variant-colors-resolver/default-variant-colors-resolver.d.ts

@@ -0,0 +1,17 @@
+import { CColor, CGradient, CTheme } from '../../theme.types';
+export interface VariantColorsResolverInput {
+    color: CColor | undefined;
+    theme: CTheme;
+    variant: string;
+    gradient?: CGradient;
+    autoContrast?: boolean;
+}
+export interface VariantColorsResolverResult {
+    background: string;
+    hover: string;
+    color: string;
+    border: string;
+    hoverColor?: string;
+}
+export type VariantColorsResolver = (input: VariantColorsResolverInput) => VariantColorsResolverResult;
+export declare const defaultVariantColorsResolver: VariantColorsResolver;

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

@@ -0,0 +1,14 @@
+import type { CColor, CColorScheme, CTheme } from '../../theme.types';
+interface GetContrastColorInput {
+    color: string | null | undefined;
+    theme: CTheme;
+    autoContrast?: boolean | undefined | null;
+    colorScheme?: CColorScheme;
+}
+export declare function getContrastColor({ color, theme, autoContrast, colorScheme, }: GetContrastColorInput): "var(--c-color-black)" | "var(--c-color-white)";
+export declare function getVirtualColorContrast(value: {
+    light: CColor;
+    dark: CColor;
+}, theme: CTheme, colorScheme: 'light' | 'dark'): "var(--c-color-black)" | "var(--c-color-white)";
+export declare function getPrimaryContrastColor(theme: CTheme, colorScheme: 'light' | 'dark'): "var(--c-color-black)" | "var(--c-color-white)";
+export {};

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

@@ -0,0 +1,2 @@
+import { CGradient, CTheme } from '../../';
+export declare function getGradient(gradient: CGradient | undefined, theme: CTheme): string;

package/lib/core/config-provider/color-functions/get-primary-shade/get-primary-shade.d.ts

@@ -0,0 +1,2 @@
+import { CColorScheme, CTheme } from '../../theme.types';
+export declare function getPrimaryShade(theme: CTheme, colorScheme: CColorScheme): import("../..").CColorShade;

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

@@ -0,0 +1,2 @@
+import { CTheme } from '../../';
+export declare function getThemeColor(color: string | undefined | null, theme: CTheme): string;

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

@@ -0,0 +1,10 @@
+export type { VariantColorsResolverInput, VariantColorsResolverResult, VariantColorsResolver } from './default-variant-colors-resolver/default-variant-colors-resolver';
+export { darken } from './darken/darken';
+export { defaultVariantColorsResolver } from './default-variant-colors-resolver/default-variant-colors-resolver';
+export { getGradient } from './get-gradient/get-gradient';
+export { getPrimaryShade } from './get-primary-shade/get-primary-shade';
+export { getThemeColor } from './get-theme-color/get-theme-color';
+export { luminance, isLightColor } from './luminance/luminance';
+export { parseThemeColor } from './parse-theme-color/parse-theme-color';
+export { rgba, alpha } from './rgba/rgba';
+export { toRgba } from './to-rgba/to-rgba';

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

@@ -0,0 +1,2 @@
+export declare function luminance(color: string): number;
+export declare function isLightColor(color: string, luminanceThreshold?: number): boolean;