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

package/dist/composable/input.d.ts

@@ -0,0 +1,97 @@
+import type { ComputedRef, PropType, Ref } from 'vue';
+export interface IInputSlot {
+    id: ComputedRef<string>;
+    isDirty: ComputedRef<boolean>;
+    isDisabled: ComputedRef<boolean>;
+    isReadonly: ComputedRef<boolean>;
+    isPure: Ref<boolean>;
+    isValid: ComputedRef<boolean | null>;
+    isValidating: Ref<boolean>;
+    reset: () => void;
+    resetValidation: () => void;
+    validate: () => Promise<string[]>;
+}
+export interface IInputProps {
+    id: string | undefined;
+    label: string | undefined;
+    description: string | undefined;
+    value: any;
+}
+export interface IUseInput {
+    id: ComputedRef<string>;
+    hasLabel: ComputedRef<boolean>;
+    hasDescription: ComputedRef<boolean>;
+}
+export declare const makeInputProps: <Defaults extends {
+    id?: unknown;
+    label?: unknown;
+    description?: unknown;
+    value?: unknown;
+    messages?: unknown;
+    persistentMessages?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Идентификатор
+     */
+    id: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Лейбл
+     */
+    label: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Описание
+     */
+    description: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Значение
+     */
+    value: {
+        type: PropType<any>;
+        default: null;
+    };
+    /**
+     * Сообщения подсказки
+     */
+    messages: {
+        type: PropType<string | string[]>;
+        default: () => never[];
+    };
+    /**
+     * Всегда показывать сообщения и подсказки
+     */
+    persistentMessages: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useInput(props: IInputProps, slots: Record<string, unknown>, name?: string): IUseInput;
+export declare function useFilteredInputProps(props: Record<string, unknown>, exclude: string[]): {
+    inputProps: Ref<{}>;
+    excludedProps: Ref<{}>;
+};
+export declare function useFilteredInputAttrs(attrs: Record<string, unknown>): {
+    rootAttrs: Ref<{}>;
+    inputAttrs: Ref<{}>;
+};
+/**
+ * Filter attributes that should be applied to
+ * the root element of a an input component. Remaining
+ * attributes should be passed to the <input> element inside.
+ */
+export declare function filterInputAttrs(attrs: Record<string, unknown>): [yes: Partial<Pick<Record<string, unknown>, any>>, no: Omit<Record<string, unknown>, any>];
+/**
+ * Filter props for input controls
+ * @param props
+ * @param exclude
+ */
+export declare function filterInputProps(props: Record<string, unknown>, exclude: string[]): (Partial<Pick<Record<string, unknown>, string>> | Omit<Record<string, unknown>, string>)[];
+export declare const excludeControls: RegExp;

package/dist/composable/items.d.ts

@@ -0,0 +1,79 @@
+import type { PropType, ComputedRef } from 'vue';
+export declare type TItemKey = boolean | string | (string | number)[] | ((item: Record<string, any>, fallback?: any) => any);
+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: TItemKey;
+    itemValue: TItemKey;
+    itemChildren: TItemKey;
+    itemProps: TItemKey;
+    returnObject: boolean;
+}
+export interface IUseItems {
+    items: ComputedRef<IInternalItem[]>;
+    itemsProps: string[];
+}
+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<TItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для значения элемента
+     */
+    itemValue: {
+        type: PropType<TItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для дочерних элементов
+     */
+    itemChildren: {
+        type: PropType<TItemKey>;
+        default: string;
+    };
+    /**
+     * Ключ для дополнительных свойств элемента
+     */
+    itemProps: {
+        type: PropType<TItemKey>;
+        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/lazy.d.ts

@@ -0,0 +1,11 @@
+import { ComputedRef } from 'vue';
+import type { Ref } from 'vue';
+export interface ILazyProps {
+    eager: boolean;
+}
+export interface IUseLazy {
+    isBooted: Ref<boolean>;
+    hasContent: ComputedRef<boolean>;
+    onAfterLeave: () => void;
+}
+export declare function useLazy(props: ILazyProps, active: Ref<boolean>): IUseLazy;

package/dist/composable/link.d.ts

@@ -0,0 +1,35 @@
+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, emit: Function): IUseLink;

package/dist/composable/loading.d.ts

@@ -0,0 +1,20 @@
+import type { ComputedRef, PropType } from 'vue';
+export interface ILoadingProp {
+    loading: boolean;
+}
+export interface IUseLoading {
+    loadingClasses: ComputedRef<string | undefined>;
+    hasLoading: ComputedRef<boolean>;
+}
+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 NestedKey: 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/overlay.d.ts

@@ -0,0 +1,99 @@
+import { PropType } from 'vue';
+export interface IOverlayProps {
+    attach: boolean | string | Element | undefined;
+    contained: boolean | undefined;
+    eager: boolean | undefined;
+    disabled: boolean | undefined;
+    persistent: boolean | undefined;
+    scrim: boolean | string | undefined;
+    modelValue: boolean | undefined;
+    zIndex: number | string | undefined;
+    contentClasses: string | string[] | Record<string, boolean> | undefined;
+    contentProps: Record<string, unknown> | undefined;
+}
+export declare const makeOverlayProps: <Defaults extends {
+    attach?: unknown;
+    contained?: unknown;
+    eager?: unknown;
+    disabled?: unknown;
+    persistent?: unknown;
+    scrim?: unknown;
+    modelValue?: unknown;
+    zIndex?: unknown;
+    contentClasses?: unknown;
+    contentProps?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Указывает, к какому DOM элементу будет прикреплен компонент.
+     * По умолчанию прикрепляется к body.
+     * Если передана строка, то ищет элемент по querySelector.
+     * Если передан объект, то считает его допустимым Node элементом.
+     */
+    attach: {
+        type: PropType<string | boolean | Element>;
+        default: boolean;
+    };
+    /**
+     * Указывает, что компонент будет прикреплен к родительскому элементу. Подразумевает absolute и attach
+     */
+    contained: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Принудительно рендерит контент компонента в DOM, даже если компонент скрыт. Полезно для SEO оптимизации.
+     */
+    eager: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Блокирует возможность клика или фокуса всплывающего компонента
+     */
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Клик за пределами компонента или esc не будет закрывать его
+     */
+    persistent: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Фон для компонента. Строкой можно передать цвет фона.
+     */
+    scrim: {
+        type: PropType<string | boolean>;
+        default: boolean;
+    };
+    /**
+     * Значение v-model. Управляет видимостью компонента.
+     */
+    modelValue: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Значение z-index для оверлея
+     */
+    zIndex: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    /**
+     * Классы для контента компонента
+     */
+    contentClasses: {
+        type: PropType<string | string[] | Record<string, boolean>>;
+        default: null;
+    };
+    /**
+     * Свойства для контента компонента
+     */
+    contentProps: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+}, Defaults>;

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

@@ -0,0 +1,5 @@
+export declare function useScopeId(): {
+    scopeId: {
+        [x: string]: string;
+    };
+};

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

@@ -0,0 +1,22 @@
+import type { Component, FunctionalComponent, PropType, TransitionProps } from 'vue';
+interface ITransitionProps extends TransitionProps {
+    transition: string | boolean | (TransitionProps & {
+        component?: Component;
+    });
+}
+export declare const makeTransitionProps: <Defaults extends {
+    transition?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Анимация компонента
+     */
+    transition: {
+        type: PropType<string | boolean | (TransitionProps & {
+            component?: Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions> | undefined;
+        })>;
+        default: string;
+        validator: (value: unknown) => boolean;
+    };
+}, Defaults>;
+export declare const CdsTransition: FunctionalComponent<ITransitionProps>;
+export {};