@central-design-system/components 2.33.0 → 3.0.0-alpha.1

package/dist/composable/validation.d.ts

@@ -0,0 +1,136 @@
+import type { PropType, ComputedRef, Ref } from 'vue';
+import type { MaybeRef } from '../utils';
+export declare type TValidationResult = string | boolean;
+export declare type TValidationRule = TValidationResult | PromiseLike<TValidationResult> | ((value: any) => TValidationResult) | ((value: any) => PromiseLike<TValidationResult>);
+export declare type TValidationOn = typeof allowedValidationOn[number];
+export interface IValidationProps {
+    disabled: boolean;
+    error: boolean;
+    errorMessages: string | string[];
+    focused: boolean;
+    maxErrors: string | number;
+    name: string | undefined;
+    label: string | undefined;
+    readonly: boolean;
+    rules: TValidationRule[];
+    modelValue: any;
+    validateOn?: TValidationOn;
+    validationValue: any;
+    hideMessages: boolean;
+}
+export interface IUseValidation {
+    errorMessages: ComputedRef<string[]>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isDirty: ComputedRef<boolean>;
+    isPure: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    validate: () => Promise<string[]>;
+    reset: () => void;
+    resetValidation: () => void;
+    validationClasses: ComputedRef<Record<string, boolean>>;
+}
+export declare const allowedValidationOn: readonly ["blur", "input", "submit"];
+export declare const makeValidationProps: <Defaults extends {
+    disabled?: unknown;
+    error?: unknown;
+    errorMessages?: unknown;
+    maxErrors?: unknown;
+    name?: unknown;
+    label?: unknown;
+    readonly?: unknown;
+    rules?: unknown;
+    modelValue?: unknown;
+    validateOn?: unknown;
+    validationValue?: unknown;
+    hideMessages?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Заблокированное состояние
+     */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Состояние ошибки
+     */
+    error: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Сообщения об ошибках
+     */
+    errorMessages: {
+        type: PropType<string | string[]>;
+        default: () => never[];
+    };
+    /**
+     * Максимально количество выводимых ошибок
+     */
+    maxErrors: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    /**
+     * Имя поля
+     */
+    name: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    /**
+     * Лейбл поля
+     */
+    label: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    /**
+     * Только для чтения
+     */
+    readonly: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Правила валидации
+     */
+    rules: {
+        type: PropType<TValidationRule[]>;
+        default: () => never[];
+    };
+    /**
+     * Значение модели
+     */
+    modelValue: {
+        type: PropType<any>;
+        default: null;
+    };
+    /**
+     * Событие для валидации
+     */
+    validateOn: {
+        type: PropType<"input" | "blur" | "submit">;
+        default: string;
+        available: readonly ["blur", "input", "submit"];
+        validator: (value: TValidationOn) => boolean;
+    };
+    /**
+     * Значение для валидации
+     */
+    validationValue: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    /**
+     * Убирает слот для сообщений об ошибках, если ошибок нет
+     */
+    hideMessages: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useValidation(props: IValidationProps, name: string, id?: MaybeRef<string | number>): IUseValidation;

package/dist/directives/click-outside/index.d.ts

@@ -0,0 +1,14 @@
+import type { DirectiveBinding } from 'vue';
+interface IClickOutsideBindingArgs {
+    handler: (event: MouseEvent) => void;
+    closeConditional?: (event: Event) => boolean;
+    include?: () => HTMLElement[];
+}
+interface IClickOutsideDirectiveBinding extends DirectiveBinding {
+    value: ((event: MouseEvent) => void) | IClickOutsideBindingArgs;
+}
+export declare const ClickOutside: {
+    mounted(el: HTMLElement, binding: IClickOutsideDirectiveBinding): void;
+    unmounted(el: HTMLElement, binding: IClickOutsideDirectiveBinding): void;
+};
+export default ClickOutside;

package/dist/directives/index.d.ts

@@ -0,0 +1 @@
+export { ClickOutside } from './click-outside';

package/dist/globals.d.ts

@@ -0,0 +1,16 @@
+declare global {
+  interface HTMLCollection {
+    [Symbol.iterator](): IterableIterator<Element>;
+  }
+
+  interface HTMLElement {
+    _clickOutside?: Record<
+      number,
+      | {
+          onClick: EventListener;
+          onMousedown: EventListener;
+        }
+      | undefined
+    > & { lastMousedownWasOutside: boolean };
+  }
+}

package/dist/plugins/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/shims-vue.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="vite/client" />
+import { PropType } from 'vue';
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
+}
+
+export type ComponentObjectPropsOptions<P = Data> = {
+  [K in keyof P]: Prop<P[K]> | null;
+};
+
+type Data = Record<string, unknown>;
+type Prop<T, D = T> = PropOptions<T, D> | PropType<T>;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+
+interface PropOptions<T = any, D = T> {
+  type?: PropType<T> | true | null;
+  required?: boolean;
+  default?: D | DefaultFactory<D> | null | undefined | object;
+  available?: readonly string[] | readonly number[];
+  validator?(value: unknown): boolean;
+}

package/dist/transitions/createTransition.d.ts

@@ -0,0 +1,38 @@
+import type { PropType, Prop } from 'vue';
+export declare function createCssTransition(name: string, origin?: string, mode?: string): import("vue").DefineComponent<{
+    group: PropType<boolean>;
+    hideOnLeave: PropType<boolean>;
+    leaveAbsolute: PropType<boolean>;
+    mode: {
+        type: PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: PropType<boolean>;
+    hideOnLeave: PropType<boolean>;
+    leaveAbsolute: PropType<boolean>;
+    mode: {
+        type: PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
+export declare function createJSTransition(name: string, functions: Record<string, any>, mode?: string): import("vue").DefineComponent<{
+    mode: Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}>>, {}>;

package/dist/transitions/expandTransition.d.ts

@@ -0,0 +1,19 @@
+interface HTMLExpandElement extends HTMLElement {
+    _parent?: (Node & ParentNode & HTMLElement) | null;
+    _initialStyle?: {
+        transition: string;
+        overflow: string;
+        height?: string | null;
+        width?: string | null;
+    };
+}
+export default function (expandedParentClass?: string, x?: boolean): {
+    onBeforeEnter(el: HTMLExpandElement): void;
+    onEnter(el: HTMLExpandElement): void;
+    onAfterEnter: (el: HTMLExpandElement) => void;
+    onEnterCancelled: (el: HTMLExpandElement) => void;
+    onLeave(el: HTMLExpandElement): void;
+    onAfterLeave: (el: HTMLExpandElement) => void;
+    onLeaveCancelled: (el: HTMLExpandElement) => void;
+};
+export {};

package/dist/transitions/index.d.ts

@@ -0,0 +1,104 @@
+export declare const CdsTransitionExpand: import("vue").DefineComponent<{
+    mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}>>, {}>;
+export declare const CdsTransitionExpandX: import("vue").DefineComponent<{
+    mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: import("vue").Prop<"default" | "in-out" | "out-in", "default" | "in-out" | "out-in">;
+}>>, {}>;
+export declare const CdsTransitionFade: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
+export declare const CdsTransitionSlideY: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;
+export declare const CdsTransitionSlideX: import("vue").DefineComponent<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    group: import("vue").PropType<boolean>;
+    hideOnLeave: import("vue").PropType<boolean>;
+    leaveAbsolute: import("vue").PropType<boolean>;
+    mode: {
+        type: import("vue").PropType<string>;
+        default: string | undefined;
+    };
+    origin: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+}>>, {
+    mode: string;
+    origin: string;
+}>;

package/dist/types/CdsOptions.d.ts

@@ -0,0 +1,3 @@
+export interface ICdsOptions {
+  cssGrid?: boolean;
+}

package/dist/utils/anchor.d.ts

@@ -0,0 +1,23 @@
+declare const block: readonly ["top", "bottom"];
+declare const inline: readonly ["start", "end", "left", "right"];
+declare type Tblock = typeof block[number];
+declare type Tinline = typeof inline[number];
+export declare type TAnchor = Tblock | Tinline | 'center' | 'center center' | `${Tblock} ${Tinline | 'center'}` | `${Tinline} ${Tblock | 'center'}`;
+export declare type ParsedAnchor = {
+    side: 'center';
+    align: 'center';
+} | {
+    side: Tblock;
+    align: 'left' | 'right' | 'center';
+} | {
+    side: 'left' | 'right';
+    align: Tblock | 'center';
+};
+/** Parse a raw anchor string into an object */
+export declare function parseAnchor(anchor: TAnchor): ParsedAnchor;
+export declare function toPhysical(str: 'center' | Tblock | Tinline): "right" | "top" | "bottom" | "left" | "center";
+export declare function flipSide(anchor: ParsedAnchor): ParsedAnchor;
+export declare function flipAlign(anchor: ParsedAnchor): ParsedAnchor;
+export declare function flipCorner(anchor: ParsedAnchor): ParsedAnchor;
+export declare function getAxis(anchor: ParsedAnchor): "y" | "x";
+export {};

package/dist/utils/animation.d.ts

@@ -0,0 +1,6 @@
+import { Box } from './box';
+/** @see https://stackoverflow.com/a/57876601/2074736 */
+export declare function nullifyTransforms(el: HTMLElement): Box;
+export declare function animate(el: Element, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation | {
+    finished: Promise<void>;
+};

package/dist/utils/box.d.ts

@@ -0,0 +1,26 @@
+export declare class Box {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor({ x, y, width, height }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare function getOverflow(a: Box, b: Box): {
+    x: {
+        before: number;
+        after: number;
+    };
+    y: {
+        before: number;
+        after: number;
+    };
+};

package/dist/utils/changeCase/lowerCase.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Localized lower case.
+ */
+export declare function localeLowerCase(str: string, locale: string): string;
+/**
+ * Lower case as a function.
+ */
+export declare function lowerCase(str: string): string;

package/dist/utils/changeCase/noCase.d.ts

@@ -0,0 +1,10 @@
+export interface IChangeCaseOptions {
+    splitRegexp?: RegExp | RegExp[];
+    stripRegexp?: RegExp | RegExp[];
+    delimiter?: string;
+    transform?: (part: string, index: number, parts: string[]) => string;
+}
+/**
+ * Normalize the string into something other libraries can manipulate easier.
+ */
+export declare function noCase(input: string, options?: IChangeCaseOptions): string;

package/dist/utils/changeCase/paramCase.d.ts

@@ -0,0 +1,3 @@
+import type { IChangeCaseOptions } from './noCase';
+export type { IChangeCaseOptions };
+export declare function paramCase(input: string, options?: IChangeCaseOptions): string;

package/dist/utils/changeCase/pascalCase.d.ts

@@ -0,0 +1,5 @@
+import { IChangeCaseOptions } from './noCase';
+export type { IChangeCaseOptions };
+export declare function pascalCaseTransform(input: string, index: number): string;
+export declare function pascalCaseTransformMerge(input: string): string;
+export declare function pascalCase(input: string, options?: IChangeCaseOptions): string;

package/dist/utils/dom.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns:
+ *  - 'null' if the node is not attached to the DOM
+ *  - the root node (HTMLDocument | ShadowRoot) otherwise
+ */
+export declare function attachedRoot(node: Node): null | HTMLDocument | ShadowRoot;

package/dist/utils/getCurrentInstance.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentInternalInstance } from 'vue';
+/**
+ * This is a wrapper around Vue's getCurrentInstance
+ * WARNING! It's not a public API and can be removed in the future
+ * @param name
+ * @param message
+ */
+export declare function getCurrentInstance(name: string, message?: string): ComponentInternalInstance;
+export declare function getCurrentInstanceName(name?: string): string;
+export declare function getUid(): number;
+export declare namespace getUid {
+    var reset: () => void;
+}

package/dist/utils/getScrollParent.d.ts

@@ -0,0 +1,3 @@
+export declare function getScrollParent(el?: HTMLElement): HTMLElement;
+export declare function getScrollParents(el?: Element | null, stopAt?: Element | null): HTMLElement[];
+export declare function hasScrollbar(el?: Element | null): boolean;

package/dist/utils/globals.d.ts

@@ -0,0 +1,4 @@
+export declare const IN_BROWSER: boolean;
+export declare const SUPPORTS_INTERSECTION: boolean;
+export declare const SUPPORTS_TOUCH: boolean;
+export declare const SUPPORTS_FOCUS_VISIBLE: boolean;

package/dist/utils/helpers.d.ts

@@ -0,0 +1,73 @@
+import type { ComponentPublicInstance, ComputedGetter, PropType, Ref, ToRefs } from 'vue';
+import type { TItemKey } from '../composable';
+export declare const keyCodes: Readonly<{
+    enter: 13;
+    tab: 9;
+    delete: 46;
+    esc: 27;
+    space: 32;
+    up: 38;
+    down: 40;
+    left: 37;
+    right: 39;
+    end: 35;
+    home: 36;
+    del: 46;
+    backspace: 8;
+    insert: 45;
+    pageup: 33;
+    pagedown: 34;
+    shift: 16;
+}>;
+export declare const classesStates: Readonly<{
+    hover: "cds-state-hover";
+    focus: "cds-state-focus";
+    active: "cds-state-active";
+    visited: "cds-state-visited";
+    disabled: "cds-state-disabled";
+    checked: "cds-state-checked";
+    indeterminate: "cds-state-indeterminate";
+    invalid: "cds-state-invalid";
+    empty: "cds-state-empty";
+    loading: "cds-state-loading";
+}>;
+export declare function isObject(obj: any): obj is object;
+export declare function mergeDeep(source?: Record<string, any>, target?: Record<string, any>, arrayFn?: (a: unknown[], b: unknown[]) => unknown[]): Record<string, any>;
+/**
+ * Wrap value in array if it's not already an array
+ * @param value
+ */
+export declare function wrapInArray<T>(value: T | T[] | null | undefined): T[];
+export declare function getNestedValue(obj: any, path: (string | number)[], fallback?: any): any;
+export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
+export declare function getPropertyFromItem(item: any, property: SelectItemKey, fallback?: any): any;
+/**
+ * @description This function is used to return a copy of the object that is composed of the picked object properties.
+ * @param obj
+ * @param paths
+ */
+export declare function pick<T extends object, U extends Extract<keyof T, string>>(obj: T, paths: U[]): [yes: MaybePick<T, U>, no: Omit<T, U>];
+/**
+ * Convert a computed ref to a record of refs.
+ * The getter function must always return an object with the same keys.
+ */
+export declare function destructComputed<T extends object>(getter: ComputedGetter<T & NotAUnion<T>>): ToRefs<T>;
+/** Array.includes but value can be any type */
+export declare function includes(arr: readonly any[], val: any): boolean;
+export declare function convertToUnit(str: number, unit?: string): string;
+export declare function convertToUnit(str: string | number | null | undefined, unit?: string): string | undefined;
+export declare function clamp(value: number, min?: number, max?: number): number;
+export declare const isOn: (key: string) => boolean;
+export declare const EventProp: PropType<(...args: any[]) => any>;
+export declare function isComponentInstance(obj: any): obj is ComponentPublicInstance;
+export declare function isFixedPosition(el?: HTMLElement): boolean;
+/**
+ * Types
+ */
+export declare type MaybeRef<T> = T | Ref<T>;
+export declare type SelectItemKey = TItemKey;
+export declare type MaybePick<T extends object, U extends Extract<keyof T, string>> = Record<string, unknown> extends T ? Partial<Pick<T, U>> : Pick<T, U>;
+export declare type EventProp<T = (...args: any[]) => any> = T;
+declare type NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;
+declare type _NotAUnion<T, U> = U extends any ? ([T] extends [U] ? unknown : never) : never;
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './propsFactory';
+export * from './helpers';
+export * from './getCurrentInstance';
+export * from './getScrollParent';
+export * from './globals';
+export * from './dom';
+export * from './anchor';
+export * from './box';
+export * from './animation';
+export * from './changeCase/noCase';
+export * from './changeCase/lowerCase';
+export * from './changeCase/pascalCase';
+export * from './changeCase/paramCase';

package/dist/utils/propsFactory.d.ts

@@ -0,0 +1,52 @@
+import type { PropType } from 'vue';
+import type { Prop, ComponentObjectPropsOptions } from '../shims-vue';
+/**
+ * Creates a factory function for props definitions.
+ * This is used to define props in a composable then override
+ * default values in an implementing component.
+ *
+ * @example Simplified signature
+ * (props: Props) => (defaults?: Record<keyof props, any>) => Props
+ *
+ * @example Usage
+ * const makeProps = propsFactory({
+ *   foo: String,
+ * })
+ *
+ * defineComponent({
+ *   props: {
+ *     ...makeProps({
+ *       foo: 'a',
+ *     }),
+ *   },
+ *   setup (props) {
+ *     // would be "string | undefined", now "string" because a default has been provided
+ *     props.foo
+ *   },
+ * }
+ */
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults | undefined) => AppendDefault<PropsOptions, Defaults>;
+export declare type AppendDefault<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeDefaults<T[P], D[P]>>;
+        default: MergeDefaults<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefaults<T[P], D[P]>>;
+        default: MergeDefaults<T[P], D[P]>;
+    };
+};
+declare type MergeDefaults<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+/**
+ * Like `Partial<T>` but doesn't care what the value is
+ */
+declare type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+declare type InferPropType<T> = T extends null ? any : T extends {
+    type: null | true;
+} ? any : T extends ObjectConstructor | {
+    type: ObjectConstructor;
+} ? Record<string, any> : T extends BooleanConstructor | {
+    type: BooleanConstructor;
+} ? boolean : T extends Prop<infer V, infer D> ? unknown extends V ? D : V : T;
+export {};

package/nuxt.js

@@ -0,0 +1,13 @@
+import { defineNuxtModule } from '@nuxt/kit';
+import { fileURLToPath } from 'node:url';
+
+export default defineNuxtModule({
+  hooks: {
+    'components:dirs'(dirs) {
+      dirs.push({
+        path: fileURLToPath(new URL('./src/components', import.meta.url)),
+        extensions: ['vue']
+      });
+    }
+  }
+});