@central-design-system/components 2.30.0 → 3.0.0-alpha.0

package/dist/composable/items.d.ts

@@ -0,0 +1,78 @@
+import { SelectItemKey } from '../utils';
+import type { PropType, ComputedRef } from 'vue';
+export interface IInternalItem<T = any> {
+    title: string;
+    value: any;
+    props: {
+        [key: string]: any;
+        title: string;
+        value: any;
+    };
+    children?: IInternalItem<T>[];
+    raw: T;
+}
+export interface IItemsProps {
+    items: any[];
+    itemTitle: SelectItemKey;
+    itemValue: SelectItemKey;
+    itemChildren: SelectItemKey;
+    itemProps: SelectItemKey;
+    returnObject: boolean;
+}
+export interface IUseItems {
+    items: ComputedRef<IInternalItem[]>;
+}
+export declare const makeItemsProps: <Defaults extends {
+    items?: unknown;
+    itemTitle?: unknown;
+    itemValue?: unknown;
+    itemChildren?: unknown;
+    itemProps?: unknown;
+    returnObject?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Массив списка элементов
+     */
+    items: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    /**
+     * Ключ для заголовка элемента
+     */
+    itemTitle: {
+        type: PropType<SelectItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для значения элемента
+     */
+    itemValue: {
+        type: PropType<SelectItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для дочерних элементов
+     */
+    itemChildren: {
+        type: PropType<SelectItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для дополнительных свойств элемента
+     */
+    itemProps: {
+        type: PropType<SelectItemKey>;
+        default: string;
+    };
+    /**
+     * Возвращать объект вместо массива
+     */
+    returnObject: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useItems(props: IItemsProps): IUseItems;
+export declare function transformItem(props: Omit<IItemsProps, 'items'>, item: any): IInternalItem;
+export declare function transformItems(props: Omit<IItemsProps, 'items'>, items: IItemsProps['items']): IInternalItem[];

package/dist/composable/link.d.ts

@@ -0,0 +1,36 @@
+import { SetupContext } from 'vue';
+import type { ComputedRef, PropType } from 'vue';
+import type { RouteLocationRaw, useLink as TUseLink } from 'vue-router';
+export interface ILinkProps {
+    href: string | undefined;
+    to: RouteLocationRaw | undefined;
+    disabled?: boolean;
+}
+export interface IUseLink extends Omit<Partial<ReturnType<typeof TUseLink>>, 'href' | 'isActive'> {
+    isActive: ComputedRef<boolean> | undefined;
+    isLink: ComputedRef<boolean>;
+    href: ComputedRef<string | undefined>;
+    to: ComputedRef<RouteLocationRaw | undefined>;
+    tag: ComputedRef<string>;
+    handleClick: (event: MouseEvent) => void;
+}
+export declare const makeLinkProps: <Defaults extends {
+    href?: unknown;
+    to?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Обычная ссылка
+     */
+    href: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Ссылка или объект Vue Router
+     */
+    to: {
+        type: PropType<RouteLocationRaw>;
+        default: undefined;
+    };
+}, Defaults>;
+export declare function useLink(props: ILinkProps, context: SetupContext<any>): IUseLink;

package/dist/composable/loading.d.ts

@@ -0,0 +1,19 @@
+import type { ComputedRef, PropType } from 'vue';
+export interface ILoadingProp {
+    loading: boolean;
+}
+export interface IUseLoading {
+    loadingClasses: ComputedRef<string | undefined>;
+}
+export declare const makeLoadingProps: <Defaults extends {
+    loading?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Состояние загрузки
+     */
+    loading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useLoading(props: ILoadingProp): IUseLoading;

package/dist/composable/nested/nested.d.ts

@@ -0,0 +1,85 @@
+import type { Ref, InjectionKey, PropType, SetupContext } from 'vue';
+import type { TSelectStrategyProp } from './selectStrategies';
+import type { TOpenStrategyProp } from './openStrategies';
+declare type TNestedProvide = {
+    id: Ref<unknown>;
+    isGroupActivator?: boolean;
+    root: {
+        children: Ref<Map<unknown, unknown[]>>;
+        parents: Ref<Map<unknown, unknown>>;
+        opened: Ref<Set<unknown>>;
+        selected: Ref<Map<unknown, 'on' | 'off' | 'indeterminate'>>;
+        selectedValues: Ref<unknown[]>;
+        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+        unregister: (id: unknown) => void;
+        open: (id: unknown, value: boolean, event?: Event) => void;
+        select: (id: unknown, value: boolean, event?: Event) => void;
+        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+    };
+};
+export interface INestedProps {
+    selectStrategy: TSelectStrategyProp | undefined;
+    openStrategy: TOpenStrategyProp | undefined;
+    selected: unknown[] | unknown;
+    opened: unknown[] | unknown;
+    required: boolean;
+    'onUpdate:selected'?: ((val: unknown[]) => void) | undefined;
+    'onUpdate:opened'?: ((val: unknown[]) => void) | undefined;
+}
+export declare const VNestedSymbol: InjectionKey<TNestedProvide>;
+export declare const emptyNested: TNestedProvide;
+export declare const makeNestedProps: <Defaults extends {
+    selectStrategy?: unknown;
+    openStrategy?: unknown;
+    opened?: unknown;
+    selected?: unknown;
+    required?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../../utils').AppendDefault<{
+    /**
+     * Стратегия выбора элементов
+     */
+    selectStrategy: PropType<TSelectStrategyProp>;
+    /**
+     * Стратегия открытия элементов
+     */
+    openStrategy: PropType<TOpenStrategyProp>;
+    /**
+     * Массив открытых элементов
+     */
+    opened: PropType<unknown[]>;
+    /**
+     * Массив выбранных элементов
+     */
+    selected: PropType<unknown[]>;
+    /**
+     * Обязательный выбор
+     */
+    required: BooleanConstructor;
+}, Defaults>;
+export declare const useNested: (props: INestedProps, ctx: SetupContext<any>) => TNestedProvide['root'];
+export declare const useNestedItem: (id: Ref<unknown>, isGroup: boolean) => {
+    id: import("vue").ComputedRef<{}>;
+    open: (open: boolean, event: Event) => void;
+    openOnSelect: (open: boolean, event?: Event) => void;
+    isOpen: import("vue").ComputedRef<boolean>;
+    parent: import("vue").ComputedRef<unknown>;
+    select: (selected: boolean, event?: Event) => void;
+    isSelected: import("vue").ComputedRef<boolean>;
+    isIndeterminate: import("vue").ComputedRef<boolean>;
+    isLeaf: import("vue").ComputedRef<boolean>;
+    isGroupActivator: boolean | undefined;
+    root: {
+        children: Ref<Map<unknown, unknown[]>>;
+        parents: Ref<Map<unknown, unknown>>;
+        opened: Ref<Set<unknown>>;
+        selected: Ref<Map<unknown, 'on' | 'off' | 'indeterminate'>>;
+        selectedValues: Ref<unknown[]>;
+        register: (id: unknown, parentId: unknown, isGroup?: boolean) => void;
+        unregister: (id: unknown) => void;
+        open: (id: unknown, value: boolean, event?: Event) => void;
+        select: (id: unknown, value: boolean, event?: Event) => void;
+        openOnSelect: (id: unknown, value: boolean, event?: Event) => void;
+    };
+};
+export declare const useNestedGroupActivator: () => void;
+export {};

package/dist/composable/nested/openStrategies.d.ts

@@ -0,0 +1,25 @@
+export declare type TOpenStrategyFn = (data: {
+    id: unknown;
+    value: boolean;
+    opened: Set<unknown>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Set<unknown>;
+export declare type TOpenSelectStrategyFn = (data: {
+    id: unknown;
+    value: boolean;
+    opened: Set<unknown>;
+    selected: Map<unknown, 'on' | 'off' | 'indeterminate'>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Set<unknown> | null;
+export declare type TOpenStrategy = {
+    open: TOpenStrategyFn;
+    select: TOpenSelectStrategyFn;
+};
+export declare type TOpenStrategyProp = 'single' | 'multiple' | 'list' | TOpenStrategy;
+export declare const singleOpenStrategy: TOpenStrategy;
+export declare const multipleOpenStrategy: TOpenStrategy;
+export declare const listOpenStrategy: TOpenStrategy;

package/dist/composable/nested/selectStrategies.d.ts

@@ -0,0 +1,21 @@
+export declare type TSelectStrategyFn = (data: {
+    id: unknown;
+    value: boolean;
+    selected: Map<unknown, 'on' | 'off' | 'indeterminate'>;
+    children: Map<unknown, unknown[]>;
+    parents: Map<unknown, unknown>;
+    event?: Event;
+}) => Map<unknown, 'on' | 'off' | 'indeterminate'>;
+export declare type TSelectStrategyTransformInFn = (value: unknown[] | undefined, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => Map<unknown, 'on' | 'off' | 'indeterminate'>;
+export declare type TSelectStrategyTransformOutFn = (value: Map<unknown, 'on' | 'off' | 'indeterminate'>, children: Map<unknown, unknown[]>, parents: Map<unknown, unknown>) => unknown[];
+export declare type TSelectStrategy = {
+    select: TSelectStrategyFn;
+    in: TSelectStrategyTransformInFn;
+    out: TSelectStrategyTransformOutFn;
+};
+export declare type TSelectStrategyProp = 'single-leaf' | 'leaf' | 'independent' | 'single-independent' | 'classic' | TSelectStrategyFn;
+export declare const independentSelectStrategy: (required?: boolean) => TSelectStrategy;
+export declare const independentSingleSelectStrategy: (required?: boolean) => TSelectStrategy;
+export declare const leafSelectStrategy: (required?: boolean) => TSelectStrategy;
+export declare const leafSingleSelectStrategy: (required?: boolean) => TSelectStrategy;
+export declare const classicSelectStrategy: (required?: boolean) => TSelectStrategy;

package/dist/composable/proxyModel.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+declare type InnerVal<T> = T extends any[] ? Readonly<T> : T;
+export declare function useProxyModel<Props extends object & {
+    [key in Prop as `onUpdate:${Prop}`]?: ((val: any) => void) | undefined;
+}, Prop extends Extract<keyof Props, string>, Inner = Props[Prop]>(props: Props, prop: Prop, defaultValue?: Props[Prop], transformIn?: (value?: Props[Prop]) => Inner, transformOut?: (value: Inner) => Props[Prop]): Ref<InnerVal<Inner>> & {
+    readonly externalValue: Props[Prop];
+};
+export {};

package/dist/composable/render.d.ts

@@ -0,0 +1,2 @@
+import { VNode } from 'vue';
+export declare function useRender(render: () => VNode): void;

package/dist/composable/size.d.ts

@@ -0,0 +1,24 @@
+import type { ComputedRef, PropType } from 'vue';
+import type { MaybeRef } from '../utils';
+export declare type TSize = typeof allowedSize[number];
+export interface ISizeProps {
+    size: TSize;
+}
+export interface IUseSize {
+    sizeClasses: ComputedRef<string>;
+}
+export declare const allowedSize: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const makeSizeProps: <Defaults extends {
+    size?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Размер
+     */
+    size: {
+        type: PropType<"xs" | "sm" | "md" | "lg" | "xl">;
+        default: string;
+        available: readonly ["xs", "sm", "md", "lg", "xl"];
+        validator: (value: TSize) => boolean;
+    };
+}, Defaults>;
+export declare function useSize(props: MaybeRef<ISizeProps>, name: string): IUseSize;

package/dist/composable/status.d.ts

@@ -0,0 +1,21 @@
+import type { ComputedRef, PropType } from 'vue';
+export declare type TStatus = typeof allowedStatus[number];
+export interface IStatusProps {
+    status: TStatus;
+}
+export interface IUseStatus {
+    statusClasses: ComputedRef<string>;
+}
+export declare const allowedStatus: readonly ["info", "success", "warning", "error", "progress"];
+export declare const makeStatusProps: <Defaults extends {
+    status?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    status: {
+        type: PropType<"error" | "info" | "success" | "warning" | "progress">;
+        default: string;
+        available: readonly ["info", "success", "warning", "error", "progress"];
+        description: string;
+        validator: (value: TStatus) => boolean;
+    };
+}, Defaults>;
+export declare function useStatus(props: IStatusProps, name: string): IUseStatus;

package/dist/composable/tag.d.ts

@@ -0,0 +1,16 @@
+import type { PropType } from 'vue';
+export interface ITagProps {
+    tag: string;
+}
+export declare const makeTagProps: <Defaults extends {
+    tag?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Пользовательский элемент для отображения
+     */
+    tag: {
+        type: PropType<string>;
+        default: string;
+        description: string;
+    };
+}, Defaults>;

package/dist/composable/text.d.ts

@@ -0,0 +1,17 @@
+import type { PropType } from 'vue';
+export interface ITextProps {
+    text: string | undefined;
+}
+export interface IUseText {
+}
+export declare const makeTextProps: <Defaults extends {
+    text?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Текст
+     */
+    text: {
+        type: PropType<string>;
+        default: undefined;
+    };
+}, Defaults>;

package/dist/composable/toggleScope.d.ts

@@ -0,0 +1,2 @@
+import type { WatchSource } from 'vue';
+export declare function useToggleScope(source: WatchSource<boolean>, fn: (reset: () => void) => void): void;

package/dist/directives/index.d.ts

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

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,9 @@
+import type { Prop } from 'vue';
+export declare function createCssTransition(): void;
+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,14 @@
+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">;
+}>>, {}>;

package/dist/types/CdsOptions.d.ts

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

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/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/helpers.d.ts

@@ -0,0 +1,49 @@
+import type { Ref } from 'vue';
+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>;
+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>];
+/**
+ * Types
+ */
+export declare type MaybeRef<T> = T | Ref<T>;
+export declare type SelectItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+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>;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './propsFactory';
+export * from './helpers';
+export * from './getCurrentInstance';
+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']
+      });
+    }
+  }
+});