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

package/dist/components/CdsTooltip/index.d.ts

@@ -0,0 +1 @@
+export { default as CdsTooltip } from './CdsTooltip.vue';

package/dist/components/CdsTree/composable/index.d.ts

@@ -0,0 +1 @@
+export * from './tree';

package/dist/components/CdsTree/composable/tree.d.ts

@@ -0,0 +1,6 @@
+import type { NTree } from '../interface';
+import type { ShallowRef } from 'vue';
+export declare function useMaxLevel<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(keyEntities: ShallowRef<Record<NTree.TKey, NTree.IDataEntity>>): {
+    maxLevel: import("vue").Ref<number>;
+    levelEntities: ShallowRef<Map<number, Set<NTree.IDataEntity<TreeDataType>>> | undefined>;
+};

package/dist/components/CdsTree/interface.d.ts

@@ -0,0 +1,60 @@
+import type { CSSProperties, VNode } from 'vue';
+export declare namespace NTree {
+    type TKey = string | number;
+    type TNodeElement = VNode<any>;
+    type TGetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+    interface IBasicDataNode {
+        checkable?: boolean;
+        selectable?: boolean;
+        disabled?: boolean;
+        disableCheckbox?: boolean;
+        icon?: any;
+        isLeaf?: boolean;
+        switcherIcon?: any;
+        class?: string;
+        style?: CSSProperties;
+        slots?: Record<string, string>;
+        [key: string]: any;
+    }
+    interface IDataNode extends IBasicDataNode {
+        children?: IDataNode[];
+        key: string | number;
+        title?: any;
+    }
+    interface IEntity {
+        node: TNodeElement;
+        index?: number;
+        key: TKey;
+        pos: string;
+        parent?: IEntity;
+        children?: IEntity[];
+    }
+    interface EventDataNode extends IDataNode {
+        expanded?: boolean;
+        selected?: boolean;
+        checked: boolean;
+        loaded?: boolean;
+        loading?: boolean;
+        halfChecked?: boolean;
+        dragOver?: boolean;
+        dragOverGapTop?: boolean;
+        dragOverGapBottom?: boolean;
+        pos?: string;
+        active?: boolean;
+        dataRef?: IDataNode;
+        parent?: IDataNode;
+        eventKey?: TKey;
+    }
+    interface IDataEntity<TreeDataType extends IBasicDataNode = IDataNode> extends Omit<IEntity, 'node' | 'parent' | 'children'> {
+        node: TreeDataType;
+        nodes: TreeDataType[];
+        parent?: IDataEntity<TreeDataType>;
+        children?: IDataEntity<TreeDataType>[];
+        level?: number;
+    }
+    interface IFieldNames {
+        title?: string;
+        key?: string;
+        children?: string;
+    }
+}

package/dist/components/CdsTree/utils/conduct.d.ts

@@ -0,0 +1,11 @@
+import type { NTree } from '../../CdsTree/interface';
+interface IConductReturnType {
+    checkedKeys: NTree.TKey[];
+    halfCheckedKeys: NTree.TKey[];
+}
+export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): boolean;
+export declare function conductCheck<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(keyList: NTree.TKey[], checked: true | {
+    checked: false;
+    halfCheckedKeys: NTree.TKey[];
+}, keyEntities: Record<NTree.TKey, NTree.IDataEntity<TreeDataType>>, maxLevel: number, levelEntities: Map<number, Set<NTree.IDataEntity<TreeDataType>>>, getCheckedDisabled?: NTree.TGetCheckDisabled<TreeDataType>): IConductReturnType;
+export {};

package/dist/components/CdsTree/utils/data.d.ts

@@ -0,0 +1,36 @@
+import { NTree } from '../interface';
+declare type TExternalGetKey = GetKey<NTree.IDataNode> | string;
+interface IWrapper {
+    posEntities: Record<string, any>;
+    keyEntities: Record<any, any>;
+}
+export declare type GetKey<RecordType> = (record: RecordType, index?: number) => NTree.TKey;
+export declare function convertDataToEntities(dataNodes: NTree.IDataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames }?: {
+    initWrapper?: (wrapper: IWrapper) => IWrapper;
+    processEntity?: (entity: NTree.IDataEntity, wrapper: IWrapper) => void;
+    onProcessFinished?: (wrapper: IWrapper) => void;
+    externalGetKey?: TExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: NTree.IFieldNames;
+}): {
+    posEntities: any;
+    keyEntities: any;
+};
+interface ITraverseConfig {
+    childrenPropName?: string;
+    externalGetKey?: TExternalGetKey;
+    fieldNames?: NTree.IFieldNames;
+}
+export declare function traverseDataNodes(dataNodes: NTree.IDataNode[], callback: (data: {
+    node: NTree.IDataNode;
+    index?: number;
+    pos: string;
+    key: NTree.TKey;
+    parentPos?: string | number | null;
+    level?: number;
+    nodes: NTree.IDataNode[];
+}) => void, config?: ITraverseConfig | string): void;
+export declare function fillFieldNames(fieldNames?: NTree.IFieldNames): Required<NTree.IFieldNames>;
+export declare function getKey(key: NTree.TKey, pos: string): NTree.TKey;
+export declare function getPosition(level?: string | number, index?: number): string;
+export {};

package/dist/components/CdsTree/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './data';
+export * from './conduct';

package/dist/components/index.d.ts

@@ -1,18 +1,77 @@
 /**
  * Automatically generated by CDS CLI
- * Generated on 2/17/2023, 8:45:21 PM
+ * Generated on 7/6/2023, 12:01:13 PM
  **/
 export { default as CdsBadge } from './CdsBadge/CdsBadge.vue';
+export { default as CdsBreadcrumbs } from './CdsBreadcrumbs/CdsBreadcrumbs.vue';
+export { default as CdsBreadcrumbsItem } from './CdsBreadcrumbs/CdsBreadcrumbsItem.vue';
 export { default as CdsButton } from './CdsButton/CdsButton.vue';
+export { default as CdsCheckbox } from './CdsCheckbox/CdsCheckbox.vue';
+export { default as CdsCheckboxGroup } from './CdsCheckbox/CdsCheckboxGroup.vue';
+export { default as CdsCombobox } from './CdsCombobox/CdsCombobox.vue';
+export { default as CdsDatePicker } from './CdsDatePicker/CdsDatePicker.vue';
 export { default as CdsDrawer } from './CdsDrawer/CdsDrawer.vue';
+export { default as CdsDropdown } from './CdsDropdown/CdsDropdown.vue';
+export { default as CdsEmptyState } from './CdsEmptyState/CdsEmptyState.vue';
+export { default as CdsForm } from './CdsForm/CdsForm.vue';
 export { default as CdsCol } from './CdsGrid/CdsCol.vue';
 export { default as CdsGrid } from './CdsGrid/CdsGrid.vue';
 export { default as CdsRow } from './CdsGrid/CdsRow.vue';
 export { default as CdsIcon } from './CdsIcon/CdsIcon.vue';
+export { default as CdsInput } from './CdsInput/CdsInput.vue';
+export { default as CdsInputCounter } from './CdsInput/CdsInputCounter.vue';
+export { default as CdsInputDescription } from './CdsInput/CdsInputDescription.vue';
+export { default as CdsInputLabel } from './CdsInput/CdsInputLabel.vue';
+export { default as CdsInputMessages } from './CdsInput/CdsInputMessages.vue';
 export { default as CdsLink } from './CdsLink/CdsLink.vue';
 export { default as CdsList } from './CdsList/CdsList.vue';
 export { default as CdsListGroup } from './CdsList/CdsListGroup.vue';
 export { default as CdsListItem } from './CdsList/CdsListItem.vue';
 export { default as CdsLoader } from './CdsLoader/CdsLoader.vue';
+export { default as CdsMenu } from './CdsMenu/CdsMenu.vue';
+export { default as CdsOverlay } from './CdsOverlay/CdsOverlay.vue';
+export { default as CdsPagination } from './CdsPagination/CdsPagination.vue';
+export { default as CdsRadio } from './CdsRadioButton/CdsRadio.vue';
+export { default as CdsRadioButton } from './CdsRadioButton/CdsRadioButton.vue';
+export { default as CdsSelect } from './CdsSelect/CdsSelect.vue';
+export { default as CdsSidebar } from './CdsSidebar/CdsSidebar.vue';
+export { default as CdsStages } from './CdsStages/CdsStages.vue';
 export { default as CdsStatus } from './CdsStatus/CdsStatus.vue';
+export { default as CdsTable } from './CdsTable/CdsTable.vue';
+export { default as CdsTableColumn } from './CdsTable/CdsTableColumn.vue';
+export { default as CdsTableColumnGroup } from './CdsTable/CdsTableColumnGroup.vue';
 export { default as CdsTag } from './CdsTag/CdsTag.vue';
+export { default as CdsTextArea } from './CdsTextArea/CdsTextArea.vue';
+export { default as CdsTextInput } from './CdsTextInput/CdsTextInput.vue';
+export { default as CdsTimePicker } from './CdsTimePicker/CdsTimePicker.vue';
+export { default as CdsTooltip } from './CdsTooltip/CdsTooltip.vue';
+export * from './CdsBadge';
+export * from './CdsBreadcrumbs';
+export * from './CdsButton';
+export * from './CdsCheckbox';
+export * from './CdsCombobox';
+export * from './CdsDatePicker';
+export * from './CdsDrawer';
+export * from './CdsDropdown';
+export * from './CdsEmptyState';
+export * from './CdsForm';
+export * from './CdsGrid';
+export * from './CdsIcon';
+export * from './CdsInput';
+export * from './CdsLink';
+export * from './CdsList';
+export * from './CdsLoader';
+export * from './CdsMenu';
+export * from './CdsOverlay';
+export * from './CdsPagination';
+export * from './CdsRadioButton';
+export * from './CdsSelect';
+export * from './CdsSidebar';
+export * from './CdsStages';
+export * from './CdsStatus';
+export * from './CdsTable';
+export * from './CdsTag';
+export * from './CdsTextArea';
+export * from './CdsTextInput';
+export * from './CdsTimePicker';
+export * from './CdsTooltip';

package/dist/composable/color.d.ts

@@ -1,4 +1,4 @@
-import { ComputedRef, PropType } from 'vue';
+import type { ComputedRef, PropType } from 'vue';
 export declare type TColor = typeof allowedColor[number];
 export declare type IColorProps = {
     color: TColor | undefined;
@@ -10,11 +10,13 @@ export declare const allowedColor: readonly ["yellow", "light-blue", "blue", "de
 export declare const makeColorProps: <Defaults extends {
     color?: unknown;
 } = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Цвет
+     */
     color: {
         type: PropType<"yellow" | "light-blue" | "blue" | "deep-purple" | "purple" | "pink">;
         available: readonly ["yellow", "light-blue", "blue", "deep-purple", "purple", "pink"];
         default: undefined;
-        description: string;
         validator: (value: TColor) => boolean;
     };
 }, Defaults>;

package/dist/composable/datetime.d.ts

@@ -0,0 +1,45 @@
+import type { ComputedRef, PropType } from 'vue';
+import type { IRawDate, TDateLocale } from '../utils';
+import type { ILocale, TAvailableLocale } from '../locale';
+export interface IDatetimeProps {
+    modelValue: string | TDatetimeValueRange | Array<string | TDatetimeValueRange>;
+    mask: string;
+    locale?: ILocale | TAvailableLocale;
+    readonly: boolean;
+    disabled: boolean;
+}
+export interface IUseDatetime {
+    editable: ComputedRef<boolean>;
+    tabindex: ComputedRef<number>;
+    getCurrentDate: (dateOnly?: boolean) => IRawDate;
+    getShortDate: (date: IRawDate) => Partial<IRawDate>;
+    getLocale: () => TDateLocale;
+    getMask: () => string;
+    decodeString: (date: string) => IRawDate;
+}
+export declare type TDatetimeValueRange = {
+    from: string | IRawDate;
+    to: string | IRawDate;
+    target?: string | IRawDate;
+};
+export declare const makeDatetimeProps: <Defaults extends {
+    modelValue?: unknown;
+    mask?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Значение модели
+     */
+    modelValue: {
+        type: PropType<string | TDatetimeValueRange | (string | TDatetimeValueRange)[]>;
+        default: null;
+    };
+    /**
+     * Формат даты/времени
+     */
+    mask: {
+        type: PropType<string>;
+        default: string;
+    };
+}, Defaults>;
+export declare function useDatetime(props: IDatetimeProps): IUseDatetime;
+export declare function getDayHash(date: IRawDate): string;

package/dist/composable/delay.d.ts

@@ -0,0 +1,29 @@
+import type { PropType } from 'vue';
+export interface IDelayProps {
+    closeDelay: number | string;
+    openDelay: number | string;
+}
+export interface IUseDelay {
+    runCloseDelay: () => void;
+    runOpenDelay: () => void;
+}
+export declare const makeDelayProps: <Defaults extends {
+    closeDelay?: unknown;
+    openDelay?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Задержка в миллисекундах перед закрытием оверлея. Только для события hover и focus.
+     */
+    closeDelay: {
+        type: PropType<string | number>;
+        default: null;
+    };
+    /**
+     * Задержка в миллисекундах перед открытием оверлея. Только для события hover и focus.
+     */
+    openDelay: {
+        type: PropType<string | number>;
+        default: null;
+    };
+}, Defaults>;
+export declare function useDelay(props: IDelayProps, cb?: (value: boolean) => void): IUseDelay;

package/dist/composable/dimensions.d.ts

@@ -0,0 +1,65 @@
+import { ComputedRef } from 'vue';
+import type { PropType } from 'vue';
+export interface IDimensionsProps {
+    height: number | string;
+    maxHeight: number | string;
+    maxWidth: number | string;
+    minHeight: number | string;
+    minWidth: number | string;
+    width: number | string;
+}
+export interface IUseDimensions {
+    dimensionsStyles: ComputedRef<Record<string, any>>;
+}
+export declare const makeDimensionProps: <Defaults extends {
+    height?: unknown;
+    width?: unknown;
+    maxHeight?: unknown;
+    maxWidth?: unknown;
+    minHeight?: unknown;
+    minWidth?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Высота
+     */
+    height: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    /**
+     * Ширина
+     */
+    width: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    /**
+     * Максимальная высота
+     */
+    maxHeight: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    /**
+     * Максимальная ширина
+     */
+    maxWidth: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    /**
+     * Минимальная высота
+     */
+    minHeight: {
+        type: PropType<string | number>;
+        default: string;
+    };
+    /**
+     * Минимальная ширина
+     */
+    minWidth: {
+        type: PropType<string | number>;
+        default: string;
+    };
+}, Defaults>;
+export declare function useDimensions(props: IDimensionsProps): IUseDimensions;

package/dist/composable/direction.d.ts

@@ -0,0 +1,24 @@
+import type { ComputedRef, PropType } from 'vue';
+import type { MaybeRef } from '../utils';
+export declare type TDirection = typeof allowedDirection[number];
+export interface IDirectionProps {
+    direction: TDirection;
+}
+export interface IUseDirection {
+    directionClasses: ComputedRef<string>;
+}
+export declare const allowedDirection: readonly ["horizontal", "vertical"];
+export declare const makeDirectionProps: <Defaults extends {
+    direction?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Расположение горизонтальное или вертикальное
+     */
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+        available: readonly ["horizontal", "vertical"];
+        validator: (value: TDirection) => boolean;
+    };
+}, Defaults>;
+export declare function useDirection(props: MaybeRef<IDirectionProps>, name: string): IUseDirection;

package/dist/composable/display.d.ts

@@ -0,0 +1,59 @@
+import type { InjectionKey, Ref } from 'vue';
+export declare const breakpoints: readonly ["xs", "sm", "md", "lg", "xl"];
+export declare const breakpointsUpDown: readonly ["smUp", "smDown", "mdUp", "mdDown", "lgUp", "lgDown", "xlUp", "xlDown"];
+export declare type TBreakpoint = typeof breakpoints[number];
+export declare type TBreakpointUpDown = typeof breakpointsUpDown[number];
+export declare type TBreakpointMap = Record<TBreakpoint, string>;
+export interface IDisplayOptions {
+    mobileBreakpoint?: number | TBreakpoint;
+    thresholds?: Partial<TDisplayThresholds>;
+}
+export interface IDisplayInstance {
+    name: Ref<TBreakpoint>;
+    xs: Ref<boolean>;
+    sm: Ref<boolean>;
+    md: Ref<boolean>;
+    lg: Ref<boolean>;
+    xl: Ref<boolean>;
+    smUp: Ref<boolean>;
+    mdUp: Ref<boolean>;
+    lgUp: Ref<boolean>;
+    xlUp: Ref<boolean>;
+    smDown: Ref<boolean>;
+    mdDown: Ref<boolean>;
+    lgDown: Ref<boolean>;
+    xlDown: Ref<boolean>;
+    mobile: Ref<boolean>;
+    mobileBreakpoint: Ref<number | TBreakpoint>;
+    width: Ref<number>;
+    height: Ref<number>;
+    platform: Ref<TDisplayPlatform>;
+    thresholds: Ref<TDisplayThresholds>;
+    ssr: boolean;
+    update(): void;
+}
+export declare type TDisplayThresholds = {
+    [key in TBreakpoint]: number;
+};
+export declare type TDisplayPlatform = {
+    android: boolean;
+    ios: boolean;
+    cordova: boolean;
+    electron: boolean;
+    chrome: boolean;
+    edge: boolean;
+    firefox: boolean;
+    opera: boolean;
+    win: boolean;
+    mac: boolean;
+    linux: boolean;
+    touch: boolean;
+    ssr: boolean;
+};
+export declare type TSSROptions = boolean | {
+    clientWidth: number;
+    clientHeight?: number;
+};
+export declare const DisplaySymbol: InjectionKey<IDisplayInstance>;
+export declare function createDisplay(options?: IDisplayOptions, ssr?: TSSROptions): IDisplayInstance;
+export declare function useDisplay(): IDisplayInstance;

package/dist/composable/field.d.ts

@@ -0,0 +1,139 @@
+import type { ComputedRef, PropType } from 'vue';
+import type { EventProp } from '../utils';
+import type { TCdsIconsName } from '@central-design-system/icons';
+export declare type TFieldTypes = typeof allowedFieldType[number];
+export interface IFieldProps {
+    active: boolean;
+    autofocus: boolean;
+    prefix: string | undefined;
+    suffix: string | undefined;
+    prependInnerIcon: TCdsIconsName | undefined;
+    appendInnerIcon: TCdsIconsName | undefined;
+    type: TFieldTypes | undefined;
+    placeholder: string | undefined;
+    counter: boolean;
+    limit: number | undefined;
+    clearable: boolean;
+    'onClick:appendInner': EventProp | undefined;
+    'onClick:prependInner': EventProp | undefined;
+}
+export interface IUseField {
+    hasPrependInnerIcon: ComputedRef<boolean>;
+    hasAppendInnerIcon: ComputedRef<boolean>;
+    fieldClasses: ComputedRef<Record<string, boolean>>;
+    fieldProps: string[];
+    handleClickPrependInner: (event: MouseEvent) => void;
+    handleClickAppendInner: (event: MouseEvent) => void;
+}
+export declare const allowedFieldType: readonly ["text", "password", "email", "number", "tel", "url"];
+export declare const makeFieldProps: <Defaults extends {
+    active?: unknown;
+    autofocus?: unknown;
+    prefix?: unknown;
+    suffix?: unknown;
+    prependInnerIcon?: unknown;
+    appendInnerIcon?: unknown;
+    type?: unknown;
+    placeholder?: unknown;
+    counter?: unknown;
+    limit?: unknown;
+    clearable?: unknown;
+    'onClick:prependInner'?: unknown;
+    'onClick:appendInner'?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    /**
+     * Активный элемент
+     */
+    active: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Автофокус
+     */
+    autofocus: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Добавить строку внутрь поля перед значением
+     */
+    prefix: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Добавить строку внутрь поля после значения
+     */
+    suffix: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Иконка внутри элемента перед значением поля
+     */
+    prependInnerIcon: {
+        type: PropType<"link" | "filters" | "search" | "add" | "alert-fill" | "alert" | "analog" | "arrow-down" | "arrow-left-bottom" | "arrow-left-top" | "arrow-left" | "arrow-right-bottom" | "arrow-right-top" | "arrow-right" | "arrow-up" | "arrows-vertical" | "calendar" | "card-bank" | "category" | "check-fill" | "check" | "chevron-down" | "chevron-left" | "chevron-right" | "chevron-up" | "chocolate-menu" | "clock" | "comment" | "company" | "compare" | "copy" | "data-cards" | "delete" | "directory" | "doc-download" | "doc" | "download" | "draggable" | "edit" | "enter" | "error-fill" | "error" | "external" | "facebook-fill" | "facebook" | "flag" | "globe" | "infinity" | "info-fill" | "info" | "list-search" | "list" | "loader" | "location" | "locked" | "login" | "logout" | "menu" | "minus" | "notification" | "overflow-menu-horizontal" | "overflow-menu-vertical" | "password" | "pin" | "plus" | "printer" | "question-fill" | "question" | "refresh" | "remove" | "sandglass" | "save" | "settings" | "shopping-cart" | "sort-date" | "star-fill" | "star" | "telegram" | "timer" | "tool" | "truck" | "unlocked" | "upload" | "user-avatar" | "user-group" | "visibility-off" | "visibility-on" | "vk" | "winner" | "workspace" | "youtube">;
+        default: undefined;
+        validator: (value: TCdsIconsName) => boolean;
+    };
+    /**
+     * Иконка внутри элемента после значения поля
+     */
+    appendInnerIcon: {
+        type: PropType<"link" | "filters" | "search" | "add" | "alert-fill" | "alert" | "analog" | "arrow-down" | "arrow-left-bottom" | "arrow-left-top" | "arrow-left" | "arrow-right-bottom" | "arrow-right-top" | "arrow-right" | "arrow-up" | "arrows-vertical" | "calendar" | "card-bank" | "category" | "check-fill" | "check" | "chevron-down" | "chevron-left" | "chevron-right" | "chevron-up" | "chocolate-menu" | "clock" | "comment" | "company" | "compare" | "copy" | "data-cards" | "delete" | "directory" | "doc-download" | "doc" | "download" | "draggable" | "edit" | "enter" | "error-fill" | "error" | "external" | "facebook-fill" | "facebook" | "flag" | "globe" | "infinity" | "info-fill" | "info" | "list-search" | "list" | "loader" | "location" | "locked" | "login" | "logout" | "menu" | "minus" | "notification" | "overflow-menu-horizontal" | "overflow-menu-vertical" | "password" | "pin" | "plus" | "printer" | "question-fill" | "question" | "refresh" | "remove" | "sandglass" | "save" | "settings" | "shopping-cart" | "sort-date" | "star-fill" | "star" | "telegram" | "timer" | "tool" | "truck" | "unlocked" | "upload" | "user-avatar" | "user-group" | "visibility-off" | "visibility-on" | "vk" | "winner" | "workspace" | "youtube">;
+        default: undefined;
+        validator: (value: TCdsIconsName) => boolean;
+    };
+    /**
+     * Тип поля
+     */
+    type: {
+        type: PropType<"number" | "text" | "password" | "email" | "tel" | "url">;
+        default: string;
+        validator: (value: TFieldTypes) => boolean;
+    };
+    /**
+     * Плейсхолдер поля
+     */
+    placeholder: {
+        type: PropType<string>;
+        default: undefined;
+    };
+    /**
+     * Счетчик введенных символов
+     */
+    counter: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Ограничение ввода по количеству символов
+     */
+    limit: {
+        type: PropType<number>;
+        default: undefined;
+    };
+    /**
+     * Очищаемое поле
+     */
+    clearable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    /**
+     * Событие клика по иконке внутри элемента перед значением поля
+     */
+    'onClick:prependInner': {
+        type: PropType<(...args: any[]) => any>;
+        default: undefined;
+    };
+    /**
+     * Событие клика по иконке внутри элемента после значения поля
+     */
+    'onClick:appendInner': {
+        type: PropType<(...args: any[]) => any>;
+        default: undefined;
+    };
+}, Defaults>;
+export declare function useField(props: IFieldProps, slots: Record<string, unknown>, name: string): IUseField;

package/dist/composable/filter.d.ts

@@ -0,0 +1,52 @@
+import type { IInternalItem } from './items';
+import type { MaybeRef } from '../utils';
+import type { PropType, Ref } from 'vue';
+export declare type TFilterMath = boolean | number | [number, number] | [number, number][];
+export interface IFilterProps {
+    customFilter?: TFilterFunction;
+    customKeyFilter?: TFilterKeyFunctions;
+    filterKeys?: TFilterKeys;
+    filterMode?: TFilterMode;
+    noFilter?: boolean;
+}
+export interface IUseFilter<T> {
+    getMatches: (item: T) => Record<string, TFilterMath> | undefined;
+    filteredItems: Ref<T[]>;
+    filteredMatches: Ref<Map<unknown, Record<string, TFilterMath>>>;
+}
+export declare const makeFilterProps: <Defaults extends {
+    customFilter?: unknown;
+    customKeyFilter?: unknown;
+    filterKeys?: unknown;
+    filterMode?: unknown;
+    noFilter?: unknown;
+} = {}>(defaults?: Defaults | undefined) => import('../utils').AppendDefault<{
+    customFilter: {
+        type: PropType<TFilterFunction>;
+        default: null;
+    };
+    customKeyFilter: {
+        type: PropType<TFilterKeyFunctions>;
+        default: null;
+    };
+    filterKeys: {
+        type: PropType<TFilterKeys>;
+        default: string;
+    };
+    filterMode: {
+        type: PropType<TFilterMode>;
+        default: string;
+    };
+    noFilter: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, Defaults>;
+export declare function useFilter<T extends IInternalItem>(props: IFilterProps, items: MaybeRef<T[]>, query: Ref<string | number | undefined>, options?: {
+    filterKeys?: MaybeRef<TFilterKeys>;
+}): IUseFilter<T>;
+declare type TFilterFunction = (value: string, query: string, item?: any) => TFilterMath;
+declare type TFilterKeyFunctions = Record<string, TFilterFunction>;
+declare type TFilterKeys = string | string[];
+declare type TFilterMode = 'some' | 'every' | 'union' | 'intersection';
+export {};