@gradient-ui/core 0.8.0 → 2.0.0

package/dist/types-cjs/directives/specular.d.cts

@@ -0,0 +1,34 @@
+import type { Directive } from 'vue';
+import { type GColor } from '../use/colorResolver.cjs';
+export type SpecularBindingValue = boolean | GColor | {
+    color?: GColor;
+    disabled?: boolean;
+    duration?: number | string;
+    easing?: string;
+    opacity?: number;
+    size?: number | string;
+};
+type SpecularOptions = {
+    color: string;
+    disabled: boolean;
+    duration: number | string;
+    easing: string;
+    opacity: number;
+    size: number | string;
+};
+type SpecularState = {
+    containerEl: HTMLElement;
+    highlightEl: HTMLElement;
+    options: SpecularOptions;
+    originalPosition: string;
+    onBlur: () => void;
+    onFocus: () => void;
+    onPointerEnter: (event: PointerEvent) => void;
+    onPointerLeave: () => void;
+    onPointerMove: (event: PointerEvent) => void;
+};
+type SpecularElement = HTMLElement & {
+    __gSpecular__?: SpecularState;
+};
+export declare const specular: Directive<SpecularElement, SpecularBindingValue>;
+export {};

package/dist/types-cjs/directives/tooltip.d.cts

@@ -0,0 +1,10 @@
+import { type Directive } from 'vue';
+import type { Placement } from '@floating-ui/dom';
+type TooltipOptions = {
+    content: string;
+    placement?: Placement;
+    offset?: number;
+};
+type TooltipBinding = string | TooltipOptions;
+export declare const vTooltip: Directive<HTMLElement, TooltipBinding>;
+export default vTooltip;

package/dist/types-cjs/index.d.cts

@@ -0,0 +1,17 @@
+import type { Plugin } from 'vue';
+import { installIcons } from './use/icon.cjs';
+import { type GradientUIOptions } from './plugin.cjs';
+export type { GradientUIOptions } from './plugin.cjs';
+import type { ColorInput } from './types/Colors.cjs';
+export * from './components/index.cjs';
+export * from './directives/index.cjs';
+export * from './services/index.cjs';
+export * from './ssr/index.cjs';
+export * from './theme/index.cjs';
+export * from './use/index.cjs';
+export { installIcons };
+export type { ColorInput };
+export type GradientUIPlugin = Plugin<[options?: GradientUIOptions]>;
+export declare function createGradientUI(options?: GradientUIOptions): GradientUIPlugin;
+export declare const GradientUI: GradientUIPlugin;
+export default GradientUI;

package/dist/types-cjs/package.json

@@ -0,0 +1,3 @@
+{
+	"type": "commonjs"
+}

package/dist/types-cjs/plugin.d.cts

@@ -0,0 +1,15 @@
+import type { App } from 'vue';
+import { type IconsOptions } from './use/icon.cjs';
+import { type GradientUIThemeOptions } from './theme/index.cjs';
+import type { ColorInput } from './types/Colors.cjs';
+import { type GradientUIDefaults } from './use/defaults.cjs';
+export interface GradientUIOptions {
+    /** Register every component globally. Disable when using explicit imports. */
+    components?: boolean;
+    icons?: boolean | Partial<IconsOptions>;
+    theme?: false | ColorInput | GradientUIThemeOptions;
+    defaults?: GradientUIDefaults;
+}
+export declare const resolveThemeOptions: (theme: GradientUIOptions["theme"]) => GradientUIThemeOptions;
+/** Install application context without importing the component catalogue. */
+export declare const installGradientUIRuntime: (app: App, options?: GradientUIOptions, inlineOptions?: GradientUIOptions) => GradientUIOptions;

package/dist/types-cjs/services/context.d.cts

@@ -0,0 +1,8 @@
+import type { InjectionKey } from 'vue';
+import type { LoadingService } from './useLoading.cjs';
+import type { SnackbarService } from './useSnackbar.cjs';
+export interface GradientUIServices {
+    loading: LoadingService;
+    snackbar: SnackbarService;
+}
+export declare const GradientUIServicesSymbol: InjectionKey<GradientUIServices>;

package/dist/types-cjs/services/index.d.cts

@@ -0,0 +1,4 @@
+export * from './context.cjs';
+export * from './runtime.cjs';
+export * from './useLoading.cjs';
+export * from './useSnackbar.cjs';

package/dist/types-cjs/services/runtime.d.cts

@@ -0,0 +1,5 @@
+import type { App } from 'vue';
+import { type GradientUIServices } from './context.cjs';
+export declare const createGradientUIServices: () => GradientUIServices;
+export declare const installGradientUIServices: (app: App) => GradientUIServices;
+export declare const getGradientUIServices: (app: App) => GradientUIServices;

package/dist/types-cjs/services/useLoading.d.cts

@@ -0,0 +1,11 @@
+import type { GLoadingProps } from '../components/ui/GLoading/types.cjs';
+export declare const createLoadingService: () => {
+    show: (options: Partial<GLoadingProps & {
+        target: string | HTMLElement;
+    }>) => void;
+    hide: () => Promise<void>;
+    visible: import("vue").Ref<boolean, boolean>;
+    dispose: () => void;
+};
+export type LoadingService = ReturnType<typeof createLoadingService>;
+export declare const useLoading: () => LoadingService;

package/dist/types-cjs/services/useSnackbar.d.cts

@@ -0,0 +1,25 @@
+import type { GSnackbarAction, GSnackbarCloseReason, GSnackbarLocation, GSnackbarProps } from '../components/ui/GSnackbar/types.cjs';
+export type GSnackbarTransition = 'fade' | 'scale' | 'slide-x' | 'slide-y';
+export interface SnackbarOptions extends Partial<Omit<GSnackbarProps, 'action' | 'transition'>> {
+    action?: GSnackbarAction | string;
+    location?: GSnackbarLocation;
+    transition?: GSnackbarTransition;
+}
+interface SnackbarItem extends SnackbarOptions {
+    id: number;
+    open: boolean;
+    action?: GSnackbarAction;
+    location: GSnackbarLocation;
+}
+export declare const createSnackbarService: () => {
+    show: (options: SnackbarOptions | string) => {
+        id: number;
+        close: (reason?: GSnackbarCloseReason) => void;
+    };
+    closeAll: () => void;
+    items: import("vue").ShallowRef<SnackbarItem[], SnackbarItem[]>;
+    dispose: () => void;
+};
+export type SnackbarService = ReturnType<typeof createSnackbarService>;
+export declare const useSnackbar: () => SnackbarService;
+export {};

package/dist/types-cjs/ssr/index.d.cts

@@ -0,0 +1,2 @@
+export * from './use/index.cjs';
+export * from './utils/index.cjs';

package/dist/types-cjs/ssr/use/appScopedState.d.cts

@@ -0,0 +1 @@
+export declare const defineAppScopedState: <T>(factory: () => T) => (() => T);

package/dist/types-cjs/ssr/use/clientLifecycle.d.cts

@@ -0,0 +1,2 @@
+import { type ClientRuntime } from '../utils/environment.cjs';
+export declare const onClientMounted: (effect: (runtime: ClientRuntime) => void | (() => void)) => void;

package/dist/types-cjs/ssr/use/hydration.d.cts

@@ -0,0 +1,2 @@
+import { type Ref } from 'vue';
+export declare const useHydrated: () => Readonly<Ref<boolean>>;

package/dist/types-cjs/ssr/use/id.d.cts

@@ -0,0 +1 @@
+export declare const useSsrId: (prefix?: string) => string;

package/dist/types-cjs/ssr/use/index.d.cts

@@ -0,0 +1,6 @@
+export * from './appScopedState.cjs';
+export * from './clientLifecycle.cjs';
+export * from './hydration.cjs';
+export * from './id.cjs';
+export * from './teleport.cjs';
+export * from './viewport.cjs';

package/dist/types-cjs/ssr/use/teleport.d.cts

@@ -0,0 +1,11 @@
+import { type App, type ComputedRef, type MaybeRefOrGetter } from 'vue';
+export interface SsrTeleportOptions {
+    /** Replace the default body target with a host supported by the SSR renderer. */
+    target: string;
+}
+export declare const installSsrTeleport: (app: App, options: SsrTeleportOptions) => void;
+export interface SsrTeleportState {
+    disabled: ComputedRef<boolean>;
+    target: ComputedRef<string>;
+}
+export declare const useSsrTeleport: (target?: MaybeRefOrGetter<string | null | undefined>, disabled?: MaybeRefOrGetter<boolean>) => SsrTeleportState;

package/dist/types-cjs/ssr/use/viewport.d.cts

@@ -0,0 +1,12 @@
+import { type App } from 'vue';
+/** Initial dimensions supplied by an SSR host for one application/request. */
+export interface SsrViewport {
+    height?: number;
+    width?: number;
+}
+/** Installs request-local viewport dimensions on a Vue application. */
+export declare const installSsrViewport: (app: App, state: SsrViewport) => void;
+/** Provides viewport dimensions to a subtree during component setup. */
+export declare const provideSsrViewport: (state: SsrViewport) => void;
+/** Reads the viewport dimensions supplied by the current application/request. */
+export declare const useSsrViewport: () => Readonly<SsrViewport> | null;

package/dist/types-cjs/ssr/utils/environment.d.cts

@@ -0,0 +1,11 @@
+export interface ClientRuntime {
+    document: Document;
+    window: Window;
+}
+export declare const canUseDom: () => boolean;
+export declare const getClientWindow: () => Window | null;
+export declare const getClientDocument: () => Document | null;
+export declare const getClientRuntime: () => ClientRuntime | null;
+export declare const isClientElement: (value: unknown) => value is Element;
+export declare const isClientHTMLElement: (value: unknown) => value is HTMLElement;
+export declare const runOnClient: <T>(callback: () => T) => T | null;

package/dist/types-cjs/ssr/utils/head.d.cts

@@ -0,0 +1,28 @@
+import { type GradientUIThemeOptions, type ThemeMode } from '../../theme/default.cjs';
+export type GradientUIHeadStyleId = 'g-theme-style' | 'g-color-style' | 'g-gradient-style';
+export interface GradientUIHeadStyle {
+    id: GradientUIHeadStyleId;
+    nonce?: string;
+    textContent: string;
+}
+export interface GradientUIHead {
+    htmlAttrs: {
+        class: string[];
+    };
+    style: GradientUIHeadStyle[];
+}
+export interface GradientUIHeadOptions {
+    /** Theme inputs used to generate request-local token CSS. */
+    theme?: GradientUIThemeOptions;
+    /** Classes used to qualify light and dark token rules. */
+    modeClasses?: Record<ThemeMode, string>;
+    /** Include the active mode class on the html element. */
+    includeModeClass?: boolean;
+    /** CSP nonce applied to every generated style descriptor. */
+    nonce?: string;
+}
+/**
+ * Creates framework-neutral SSR head descriptors without touching the DOM.
+ * The result is request-local and can be passed to any head manager.
+ */
+export declare const createGradientUIHead: (options?: GradientUIHeadOptions) => GradientUIHead;

package/dist/types-cjs/ssr/utils/index.d.cts

@@ -0,0 +1,3 @@
+export * from './environment.cjs';
+export * from './head.cjs';
+export * from './mount.cjs';

package/dist/types-cjs/ssr/utils/mount.d.cts

@@ -0,0 +1,21 @@
+import { type App, type Component, type ComponentPublicInstance } from 'vue';
+export type ClientMountTarget = string | HTMLElement;
+export interface ClientComponentMount<TInstance extends ComponentPublicInstance = ComponentPublicInstance> {
+    app: App;
+    container: HTMLElement;
+    instance: TInstance;
+    unmount: () => void;
+}
+export interface MountClientComponentOptions {
+    containerClass?: string;
+    props?: Record<string, unknown> | null;
+    target?: ClientMountTarget;
+}
+export declare const resolveClientTarget: (target?: ClientMountTarget) => HTMLElement | null;
+export declare const mountClientComponent: <TInstance extends ComponentPublicInstance = ComponentPublicInstance>(component: Component, options?: MountClientComponentOptions) => ClientComponentMount<TInstance> | null;
+export declare const mountClientStyle: (id: string, cssText: string) => HTMLStyleElement | null;
+export interface ClientElementRegistry {
+    mount: (id: string, createElement: (document: Document) => Element) => () => void;
+    clear: () => void;
+}
+export declare const createClientElementRegistry: () => ClientElementRegistry;

package/dist/types-cjs/theme/color.d.cts

@@ -0,0 +1,11 @@
+import type { ColorInput } from '../types/Colors.cjs';
+export interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+export declare const parseColor: (input: ColorInput) => RgbColor | null;
+export declare const rgbToHex: ({ r, g, b }: RgbColor) => string;
+export declare const rgbToChannels: ({ r, g, b }: RgbColor) => string;
+export declare const colorToHex: (input: ColorInput, fallback: string) => string;
+export declare const getContrastingColor: (color: ColorInput) => "#ffffff" | "#0d0d12";

package/dist/types-cjs/theme/colorSeeds.d.cts

@@ -0,0 +1,22 @@
+export declare const COLOR_SEEDS: {
+    readonly red: "#F44336";
+    readonly pink: "#E91E63";
+    readonly purple: "#9C27B0";
+    readonly deepPurple: "#673AB7";
+    readonly indigo: "#3F51B5";
+    readonly blue: "#2196F3";
+    readonly lightBlue: "#03A9F4";
+    readonly cyan: "#00BCD4";
+    readonly teal: "#009688";
+    readonly green: "#4CAF50";
+    readonly lightGreen: "#8BC34A";
+    readonly lime: "#CDDC39";
+    readonly yellow: "#FFEB3B";
+    readonly amber: "#FFC107";
+    readonly orange: "#FF9800";
+    readonly deepOrange: "#FF5722";
+    readonly brown: "#795548";
+    readonly grey: "#9E9E9E";
+    readonly blueGrey: "#607D8B";
+};
+export type ColorFamily = keyof typeof COLOR_SEEDS;

package/dist/types-cjs/theme/colorSystem.d.cts

@@ -0,0 +1,12 @@
+import { type ColorPalettePair } from './palette.cjs';
+import type { ThemeColorExtensions, ThemeTokens } from './types.cjs';
+import type { ColorInput } from '../types/Colors.cjs';
+export interface ColorSystem {
+    colors: ThemeTokens;
+    gradients: ThemeTokens;
+    palettes: Record<string, ColorPalettePair>;
+}
+export interface ColorSystemOptions {
+    colors?: ThemeColorExtensions;
+}
+export declare const createColorSystem: (seed: ColorInput, options?: ColorSystemOptions) => ColorSystem;

package/dist/types-cjs/theme/cssTokens.d.cts

@@ -0,0 +1,8 @@
+import type { ThemeTokens } from './types.cjs';
+export interface TokenStyleOptions {
+    className: string;
+    id: string;
+    prefix: string;
+}
+export declare const createTokensCSS: (tokens: ThemeTokens, { className, prefix }: Pick<TokenStyleOptions, "className" | "prefix">) => string;
+export declare const applyTokensToCSS: (tokens: ThemeTokens, { className, id, prefix }: TokenStyleOptions) => HTMLStyleElement | null;

package/dist/types-cjs/theme/default.d.cts

@@ -0,0 +1,51 @@
+import type { ThemeColorExtensions, ThemeMode, ThemeTokens } from './types.cjs';
+import type { ColorInput } from '../types/Colors.cjs';
+import { DEFAULT_SEED } from '@gradient-ui/gradient-engine';
+import { type App, type Ref, type ShallowRef } from 'vue';
+export { DEFAULT_SEED };
+export interface SeedTheme {
+    seedColor: ColorInput;
+}
+export type { ThemeMode } from './types.cjs';
+export interface GradientUIThemeOptions {
+    applyToDom?: boolean;
+    seed?: ColorInput;
+    mode?: ThemeMode;
+    autoApply?: boolean;
+    colors?: ThemeColorExtensions;
+}
+export interface CreateDefaultThemeOptions {
+    colors?: ThemeColorExtensions;
+    applyToDom?: boolean;
+}
+export interface GeneratedTheme {
+    tokens: {
+        theme: ThemeTokens;
+        colors: ThemeTokens;
+        gradients: ThemeTokens;
+    };
+    classes: string[];
+    cssText: string;
+    themeCSSText: string;
+    colorsCSSText: string;
+    gradientCSSText: string;
+    themeCSS: HTMLStyleElement | null;
+    colorsCSS: HTMLStyleElement | null;
+    gradientCSS: HTMLStyleElement | null;
+}
+export interface GradientUITheme {
+    seed: Ref<ColorInput>;
+    mode: Ref<ThemeMode>;
+    result: ShallowRef<GeneratedTheme | null>;
+    apply: () => GeneratedTheme | null;
+    setSeed: (seed: ColorInput) => GeneratedTheme | null;
+    setMode: (mode: ThemeMode) => GeneratedTheme | null;
+    toggleMode: () => GeneratedTheme | null;
+}
+export declare const createDefaultLightTheme: (seed?: ColorInput, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createDefaultDarkTheme: (seed?: ColorInput, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createDefaultTheme: (seed?: ColorInput, mode?: ThemeMode, options?: CreateDefaultThemeOptions) => GeneratedTheme;
+export declare const createTheme: (options?: GradientUIThemeOptions) => GradientUITheme;
+export declare const provideTheme: (theme?: GradientUITheme) => GradientUITheme;
+export declare const installTheme: (app: App, theme: GradientUITheme) => void;
+export declare const useTheme: () => GradientUITheme | null;

package/dist/types-cjs/theme/gradient.d.cts

@@ -0,0 +1 @@
+export * from '@gradient-ui/gradient-engine';

package/dist/types-cjs/theme/index.d.cts

@@ -0,0 +1,13 @@
+export { createTokensCSS } from './cssTokens.cjs';
+export { colorToHex, getContrastingColor, parseColor, rgbToChannels, rgbToHex, type RgbColor } from './color.cjs';
+export { COLOR_SHADES, ON_SHADE_TONES, SHADE_TONES, createOnPalette, createPalette, createPalettePair, type ColorPalette, type ColorPalettePair, type ColorShade } from './palette.cjs';
+export * as gradientAnimation from '@gradient-ui/gradient-engine/animation';
+export * as gradientCore from '@gradient-ui/gradient-engine/core';
+export * as gradientEffects from '@gradient-ui/gradient-engine/effects';
+export * as gradientFormatters from '@gradient-ui/gradient-engine/formatters';
+export * as gradientMaterial from '@gradient-ui/gradient-engine/material';
+export { createGradient, createGradientModel, createGradientModelFromColor, createGradientFromColor, createGradientMaterial, createGradientPreset, createGradientTokens, createLinearGradient, DEFAULT_GRADIENT_MORPH_BLEND_MODE, defineGradientPreset, defineGradientPresetRegistry, getGradientPreset, GRADIENT_MORPH_BLEND_MODES, gradientPresets, isGradientMorphBlendMode, resolveGradientMorphBlendMode, toCssGradient, toGradientAnimationCSS, toGradientBoxShadow, toGradientDropShadow, createGradientMorphBlobs, toGradientMorphCSS, toGradientMorphFilter, toGradientMorphFilterMarkup, toCanvasGradient, toSvgGradient, toSvgGradientMarkup, toSvgPathAnimationMarkup, toSvgSourceAnimationMarkup, type GradientAnimationOptions, type GradientAnimationPreset, type CanvasGradientOptions, type CreatedGradientPreset, type CreatedGradientTokens, type CreatedGradientMaterial, type GradientAnimationTokenEntry, type GradientDirection, type GradientEffectTokenEntry, type GradientModel, type GradientMaterialOptions, type GradientMorphBlob, type GradientMorphBlendMode, type GradientMorphOptions, type GradientMorphPreset, type GradientOptions, type GradientPreset, type GradientPresetName, type GradientPresetRegistry, type GradientRecipe, type GradientShadowOptions, type GradientShape, type GradientStop, type GradientTokenEntry, type GradientTokenOptions, type GradientTokenRecipe, type GradientType, type SvgGradientOptions, type SvgPathAnimationOptions, type SvgSourceAnimationOptions } from '@gradient-ui/gradient-engine';
+export { createColorSystem, type ColorSystem, type ColorSystemOptions } from './colorSystem.cjs';
+export { createSemanticTokens } from './scheme.cjs';
+export { DEFAULT_SEED, createDefaultDarkTheme, createDefaultLightTheme, createDefaultTheme, createTheme, installTheme, provideTheme, useTheme, type CreateDefaultThemeOptions, type GeneratedTheme, type GradientUITheme, type GradientUIThemeOptions, type SeedTheme, type ThemeMode } from './default.cjs';
+export type { ThemeColorDefinition, ThemeColorExtensions, ThemeColorValue, ThemeTokens } from './types.cjs';

package/dist/types-cjs/theme/palette.d.cts

@@ -0,0 +1,13 @@
+import type { ColorInput } from '../types/Colors.cjs';
+export declare const COLOR_SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
+export type ColorShade = (typeof COLOR_SHADES)[number];
+export type ColorPalette = Record<ColorShade, string>;
+export interface ColorPalettePair {
+    colors: ColorPalette;
+    onColors: ColorPalette;
+}
+export declare const SHADE_TONES: Record<ColorShade, number>;
+export declare const ON_SHADE_TONES: Record<ColorShade, number>;
+export declare const createPalette: (seed: ColorInput) => ColorPalette;
+export declare const createOnPalette: (seed: ColorInput) => ColorPalette;
+export declare const createPalettePair: (seed: ColorInput) => ColorPalettePair;

package/dist/types-cjs/theme/scheme.d.cts

@@ -0,0 +1,2 @@
+import type { ThemeMode, ThemeTokens } from './types.cjs';
+export declare const createSemanticTokens: (seed: string, mode: ThemeMode) => ThemeTokens;

package/dist/types-cjs/theme/types.d.cts

@@ -0,0 +1,11 @@
+import type { ColorInput } from '../types/Colors.cjs';
+export type ThemeMode = 'light' | 'dark';
+export type ThemeTokens = Record<string, string>;
+export interface ThemeColorDefinition {
+    color: ColorInput;
+    onColor?: ColorInput;
+    palette?: boolean;
+    gradient?: string | false;
+}
+export type ThemeColorValue = ColorInput | ThemeColorDefinition;
+export type ThemeColorExtensions = Record<string, ThemeColorValue>;

package/dist/types-cjs/types/Colors.d.cts

@@ -0,0 +1,2 @@
+export type ColorInput = string | number;
+export type ArgbColor = number;

package/dist/types-cjs/types/CommonTypes.d.cts

@@ -0,0 +1,26 @@
+import * as mdi from '@mdi/js';
+import type { ExcludeString } from './UtilityTypes.cjs';
+import type { CamelToKebab } from './UtilityTypes.cjs';
+export type MdiIcon = ExcludeString<CamelToKebab<keyof typeof mdi>, 'mdi-'>;
+export interface PLAProps {
+    label?: string;
+    appendIcon?: MdiIcon;
+    prependIcon?: MdiIcon;
+}
+export interface PLASlots {
+    default?: () => unknown;
+    prepend?: () => unknown;
+    append?: () => unknown;
+}
+export type PXtype = number | string;
+export type Sizes = 's' | 'm' | 'l' | 'xl';
+export type Placement = 'top' | 'bottom' | 'left' | 'right' | 'center';
+type OptionalFields = {
+    [key: string]: any;
+};
+export interface option extends OptionalFields {
+    label: string;
+    value: string | number | object;
+}
+export type StringeredNumber = number | `${number}`;
+export {};

package/dist/types-cjs/types/UtilityTypes.d.cts

@@ -0,0 +1,2 @@
+export type CamelToKebab<T extends string> = T extends `${infer First}${infer Rest}` ? `${First extends Uppercase<First> ? '-' : ''}${Lowercase<First>}${CamelToKebab<Rest>}` : T;
+export type ExcludeString<T, K extends string> = T extends `${K}${infer Rest}` ? Rest : never;

package/dist/types-cjs/use/PLA.d.cts

@@ -0,0 +1,101 @@
+import type { PropType } from 'vue';
+import { type MdiIcon } from './../types/CommonTypes.cjs';
+export declare const makePLAProps: <Defaults extends {
+    prepend?: unknown;
+    append?: unknown;
+    label?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    prepend: {
+        type: PropType<Defaults["prepend"] extends infer T ? T extends Defaults["prepend"] ? T extends unknown ? MdiIcon : MdiIcon | T : never : never>;
+        default: Defaults["prepend"] extends infer T_1 ? T_1 extends Defaults["prepend"] ? T_1 extends unknown ? MdiIcon : NonNullable<MdiIcon> | T_1 : never : never;
+    };
+    append: {
+        type: PropType<Defaults["append"] extends infer T_2 ? T_2 extends Defaults["append"] ? T_2 extends unknown ? MdiIcon : MdiIcon | T_2 : never : never>;
+        default: Defaults["append"] extends infer T_3 ? T_3 extends Defaults["append"] ? T_3 extends unknown ? MdiIcon : NonNullable<MdiIcon> | T_3 : never : never;
+    };
+    label: {
+        type: PropType<Defaults["label"] extends infer T_4 ? T_4 extends Defaults["label"] ? T_4 extends unknown ? string : string | T_4 : never : never>;
+        default: Defaults["label"] extends infer T_5 ? T_5 extends Defaults["label"] ? T_5 extends unknown ? string : string | T_5 : never : never;
+    };
+};
+export declare const makePLASlots: <D extends Partial<{
+    prepend: (_props: {
+        icon: string;
+    }) => string;
+    append: (_props: {
+        label: string;
+    }) => string;
+    label: (props: {
+        label: string;
+    }) => string;
+}> = object>(defaults?: D | undefined) => {
+    prepend: {
+        fn: "prepend" extends infer T ? T extends "prepend" ? T extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T] | D[T] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T] : never : never;
+    };
+    append: {
+        fn: "append" extends infer T_1 ? T_1 extends "append" ? T_1 extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_1] | D[T_1] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_1] : never : never;
+    };
+    label: {
+        fn: "label" extends infer T_2 ? T_2 extends "label" ? T_2 extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_2] | D[T_2] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_2] : never : never;
+    };
+};

package/dist/types-cjs/use/actionProps.d.cts

@@ -0,0 +1,38 @@
+export declare const makeActionProps: <Defaults extends {
+    rounded?: unknown;
+    size?: unknown;
+    variant?: unknown;
+    removable?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    rounded: Omit<{
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<Defaults["rounded"] extends infer T ? T extends Defaults["rounded"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["rounded"] extends infer T_1 ? T_1 extends Defaults["rounded"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+    size: Omit<Omit<{
+        type: import("vue").PropType<import("../types/CommonTypes.cjs").Sizes>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<import("../types/CommonTypes.cjs").Sizes>;
+        default: import("../types/CommonTypes.cjs").Sizes;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<Defaults["size"] extends infer T_2 ? T_2 extends Defaults["size"] ? T_2 extends unknown ? import("../types/CommonTypes.cjs").Sizes : import("../types/CommonTypes.cjs").Sizes | T_2 : never : never>;
+        default: Defaults["size"] extends infer T_3 ? T_3 extends Defaults["size"] ? T_3 extends unknown ? import("../types/CommonTypes.cjs").Sizes : NonNullable<import("../types/CommonTypes.cjs").Sizes> | T_3 : never : never;
+    };
+    variant: Omit<Omit<{
+        type: import("vue").PropType<import("./variant.cjs").GVariant>;
+        default: string;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<import("./variant.cjs").GVariant>;
+        default: import("./variant.cjs").GVariant;
+    }, "default" | "type"> & {
+        type: import("vue").PropType<Defaults["variant"] extends infer T_4 ? T_4 extends Defaults["variant"] ? T_4 extends unknown ? import("./variant.cjs").GVariant : import("./variant.cjs").GVariant | T_4 : never : never>;
+        default: Defaults["variant"] extends infer T_5 ? T_5 extends Defaults["variant"] ? T_5 extends unknown ? import("./variant.cjs").GVariant : NonNullable<import("./variant.cjs").GVariant> | T_5 : never : never;
+    };
+    removable: {
+        type: import("vue").PropType<Defaults["removable"] extends infer T_6 ? T_6 extends Defaults["removable"] ? T_6 extends unknown ? boolean : boolean | T_6 : never : never>;
+        default: Defaults["removable"] extends infer T_7 ? T_7 extends Defaults["removable"] ? T_7 extends unknown ? boolean : boolean | T_7 : never : never;
+    };
+};