@codemonster-ru/vueforge 0.92.0 → 0.94.0

package/dist/package/components/button-group.vue.d.ts

@@ -22,8 +22,8 @@ type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
     disabled: boolean;
     size: Size;
-    orientation: Orientation;
     variant: Variant;
+    orientation: Orientation;
     severity: Severity;
     attached: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;

package/dist/package/components/button.vue.d.ts

@@ -33,11 +33,11 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     label: string;
     disabled: boolean;
     size: string;
+    variant: string;
     icon: string;
     loading: boolean;
     rounded: boolean;
     iconPos: "top" | "right" | "bottom" | "left";
-    variant: string;
     severity: string;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/package/components/calendar.vue.d.ts

@@ -20,10 +20,10 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }>, {
     disabled: boolean;
-    size: Size;
-    ariaLabel: string;
     modelValue: string;
+    size: Size;
     variant: Variant;
+    ariaLabel: string;
     readonly: boolean;
     min: string;
     max: string;

package/dist/package/components/carousel.vue.d.ts

@@ -59,9 +59,9 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     "onUpdate:modelValue"?: ((index: number) => any) | undefined;
 }>, {
     disabled: boolean;
-    items: Array<unknown>;
-    ariaLabel: string;
     modelValue: number;
+    ariaLabel: string;
+    items: Array<unknown>;
     pt: PassThroughOptions;
     unstyled: boolean;
     autoplay: boolean;

package/dist/package/components/cascade-select-types.d.ts

@@ -0,0 +1,8 @@
+import { TreeValue } from './tree.vue';
+export interface CascadeSelectItem {
+    key: TreeValue;
+    label: string;
+    disabled?: boolean;
+    hasChildren?: boolean;
+    children?: Array<CascadeSelectItem>;
+}

package/dist/package/components/cascade-select.vue.d.ts

@@ -0,0 +1,96 @@
+import { TreeValue } from './tree.vue';
+import { CascadeSelectItem } from './cascade-select-types';
+type Size = 'small' | 'normal' | 'large';
+type Variant = 'filled' | 'outlined';
+type CascadeModelValue = TreeValue | Array<TreeValue> | undefined;
+interface Props {
+    items?: Array<CascadeSelectItem>;
+    modelValue?: CascadeModelValue;
+    expandedKeys?: Array<TreeValue>;
+    multiple?: boolean;
+    selectable?: boolean;
+    expandOnClick?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    loadingBranchText?: string;
+    emptyText?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    filter?: boolean;
+    clearable?: boolean;
+    variant?: Variant;
+    size?: Size;
+    autoLoadOnExpand?: boolean;
+    loadChildren?: (node: CascadeSelectItem) => Promise<Array<CascadeSelectItem>>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {
+            loading: boolean;
+            node: import('./tree.vue').TreeItem;
+            level: number;
+            selected: boolean;
+            expanded: boolean;
+            disabled: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    search: (...args: any[]) => void;
+    blur: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+    focus: (...args: any[]) => void;
+    toggle: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    "update:expandedKeys": (...args: any[]) => void;
+    nodeClick: (...args: any[]) => void;
+    branchLoadStart: (...args: any[]) => void;
+    branchLoad: (...args: any[]) => void;
+    branchLoadError: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onSearch?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onChange?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onToggle?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:expandedKeys"?: ((...args: any[]) => any) | undefined;
+    onNodeClick?: ((...args: any[]) => any) | undefined;
+    onBranchLoadStart?: ((...args: any[]) => any) | undefined;
+    onBranchLoad?: ((...args: any[]) => any) | undefined;
+    onBranchLoadError?: ((...args: any[]) => any) | undefined;
+}>, {
+    filter: boolean;
+    disabled: boolean;
+    modelValue: TreeValue | TreeValue[];
+    size: Size;
+    variant: Variant;
+    items: Array<CascadeSelectItem>;
+    expandedKeys: Array<TreeValue>;
+    multiple: boolean;
+    loading: boolean;
+    placeholder: string;
+    readonly: boolean;
+    clearable: boolean;
+    loadingText: string;
+    emptyText: string;
+    searchPlaceholder: string;
+    selectable: boolean;
+    expandOnClick: boolean;
+    loadingBranchText: string;
+    autoLoadOnExpand: boolean;
+    loadChildren: (node: CascadeSelectItem) => Promise<Array<CascadeSelectItem>>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/package/components/chart.vue.d.ts

@@ -11,6 +11,9 @@ interface Props {
     loadingText?: string;
     emptyText?: string;
     ariaLabel?: string;
+    lazy?: boolean;
+    lazyRootMargin?: string;
+    lazyThreshold?: number;
     pt?: PassThroughOptions;
     unstyled?: boolean;
 }
@@ -24,6 +27,7 @@ declare function __VLS_template(): {
         empty?: () => unknown;
     };
     refs: {
+        rootRef: HTMLDivElement;
         canvasRef: HTMLCanvasElement;
     };
     rootEl: HTMLDivElement;
@@ -40,6 +44,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     onReady?: ((instance: ChartAdapterInstance) => any) | undefined;
 }>, {
     type: ChartType;
+    lazy: boolean;
     data: ChartData;
     ariaLabel: string;
     loading: boolean;
@@ -49,9 +54,12 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     unstyled: boolean;
     loadingText: string;
     emptyText: string;
-    options: Record<string, unknown>;
     adapter: ChartAdapter;
+    lazyRootMargin: string;
+    lazyThreshold: number;
+    options: Record<string, unknown>;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootRef: HTMLDivElement;
     canvasRef: HTMLCanvasElement;
 }, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

package/dist/package/components/checkbox.vue.d.ts

@@ -32,11 +32,11 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     label: string;
     disabled: boolean;
     name: string;
-    required: boolean;
-    id: string;
-    ariaLabel: string;
     modelValue: boolean;
     variant: Variant;
+    id: string;
+    ariaLabel: string;
+    required: boolean;
     ariaLabelledby: string;
     ariaDescribedby: string;
     ariaInvalid: boolean | "true" | "false";

package/dist/package/components/chip.vue.d.ts

@@ -31,9 +31,9 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     label: string;
     disabled: boolean;
     size: ChipSize;
-    icon: string;
-    ariaLabel: string;
     variant: ChipVariant;
+    ariaLabel: string;
+    icon: string;
     severity: ChipSeverity;
     closeLabel: string;
     closable: boolean;

package/dist/package/components/code-editor-adapter.d.ts

@@ -0,0 +1,56 @@
+export interface CodeEditorConfig {
+    value: string;
+    language?: string;
+    theme?: string;
+    readonly?: boolean;
+    options?: Record<string, unknown>;
+    onChange?: (value: string) => void;
+}
+export interface CodeEditorAdapterInstance {
+    [key: string]: unknown;
+}
+export interface CodeEditorAdapter {
+    mount: (container: HTMLElement, config: CodeEditorConfig) => CodeEditorAdapterInstance;
+    update?: (instance: CodeEditorAdapterInstance, config: CodeEditorConfig) => void;
+    setValue?: (instance: CodeEditorAdapterInstance, value: string) => void;
+    getValue?: (instance: CodeEditorAdapterInstance) => string;
+    setReadonly?: (instance: CodeEditorAdapterInstance, readonly: boolean) => void;
+    setTheme?: (instance: CodeEditorAdapterInstance, theme: string) => void;
+    focus?: (instance: CodeEditorAdapterInstance) => void;
+    destroy?: (instance: CodeEditorAdapterInstance) => void;
+}
+type MonacoLikeModel = {
+    getValue: () => string;
+    setValue: (value: string) => void;
+    dispose?: () => void;
+};
+type MonacoLikeEditorInstance = {
+    getValue: () => string;
+    setValue: (value: string) => void;
+    updateOptions: (options: Record<string, unknown>) => void;
+    onDidChangeModelContent: (callback: () => void) => {
+        dispose: () => void;
+    };
+    dispose: () => void;
+};
+type MonacoLikeNamespace = {
+    editor: {
+        create: (container: HTMLElement, options: Record<string, unknown>) => MonacoLikeEditorInstance;
+        setTheme?: (theme: string) => void;
+        createModel?: (value: string, language?: string) => MonacoLikeModel;
+    };
+};
+export declare const createMonacoAdapter: (monaco: MonacoLikeNamespace) => CodeEditorAdapter;
+type CodeMirrorLikeView = {
+    destroy: () => void;
+    dispatch?: (value: unknown) => void;
+    focus?: () => void;
+    state?: {
+        doc?: {
+            toString?: () => string;
+        };
+    };
+};
+type CodeMirrorFactory = (container: HTMLElement, config: CodeEditorConfig) => CodeMirrorLikeView;
+export declare const createCodeMirrorAdapter: (factory: CodeMirrorFactory) => CodeEditorAdapter;
+export {};

package/dist/package/components/code-editor.vue.d.ts

@@ -0,0 +1,85 @@
+import { CodeEditorAdapter, CodeEditorAdapterInstance } from './code-editor-adapter';
+interface Props {
+    modelValue?: string;
+    adapter?: CodeEditorAdapter;
+    language?: string;
+    theme?: string;
+    readonly?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    noAdapterText?: string;
+    showHeader?: boolean;
+    languageLabel?: string;
+    readonlyLabel?: string;
+    editableLabel?: string;
+    ariaLabel?: string;
+    lazy?: boolean;
+    lazyRootMargin?: string;
+    lazyThreshold?: number;
+    options?: Record<string, unknown>;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        loading?: () => unknown;
+        empty?: () => unknown;
+    }> & {
+        loading?: () => unknown;
+        empty?: () => unknown;
+    };
+    refs: {
+        rootRef: HTMLElement;
+        editorRef: HTMLDivElement;
+    };
+    rootEl: HTMLElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {
+    focus: () => void;
+    refresh: () => void;
+    getValue: () => string;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    change: (payload: {
+        value: string;
+    }) => any;
+    error: (error: Error) => any;
+    "update:modelValue": (value: string) => any;
+    ready: (instance: CodeEditorAdapterInstance) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onChange?: ((payload: {
+        value: string;
+    }) => any) | undefined;
+    onError?: ((error: Error) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onReady?: ((instance: CodeEditorAdapterInstance) => any) | undefined;
+}>, {
+    disabled: boolean;
+    lazy: boolean;
+    modelValue: string;
+    ariaLabel: string;
+    loading: boolean;
+    readonly: boolean;
+    loadingText: string;
+    language: string;
+    theme: string;
+    adapter: CodeEditorAdapter;
+    noAdapterText: string;
+    showHeader: boolean;
+    languageLabel: string;
+    readonlyLabel: string;
+    editableLabel: string;
+    lazyRootMargin: string;
+    lazyThreshold: number;
+    options: Record<string, unknown>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootRef: HTMLElement;
+    editorRef: HTMLDivElement;
+}, HTMLElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/package/components/color-picker.vue.d.ts

@@ -25,10 +25,10 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     onOpen?: ((...args: any[]) => any) | undefined;
 }>, {
     disabled: boolean;
-    size: Size;
-    ariaLabel: string;
     modelValue: string;
+    size: Size;
     variant: Variant;
+    ariaLabel: string;
     placeholder: string;
     readonly: boolean;
     format: Format;

package/dist/package/components/combobox.vue.d.ts

@@ -48,11 +48,11 @@ declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, imp
     filter: boolean;
     disabled: boolean;
     strict: boolean;
+    modelValue: OptionValue;
     size: Size;
+    variant: Variant;
     ariaLabel: string;
-    modelValue: OptionValue;
     loading: boolean;
-    variant: Variant;
     placeholder: string;
     readonly: boolean;
     ariaLabelledby: string;

package/dist/package/components/command-palette.vue.d.ts

@@ -39,9 +39,9 @@ declare const _default: import('vue').DefineComponent<Props, {
     onOpen?: ((...args: any[]) => any) | undefined;
 }>, {
     filter: boolean;
-    items: Array<CommandPaletteItem>;
-    ariaLabel: string;
     modelValue: boolean;
+    ariaLabel: string;
+    items: Array<CommandPaletteItem>;
     placeholder: string;
     closeOnOverlay: boolean;
     emptyText: string;

package/dist/package/components/comment-thread.vue.d.ts

@@ -0,0 +1,72 @@
+type DateLike = string | number | Date;
+export interface CommentThreadAuthor {
+    id?: string | number;
+    name: string;
+    avatar?: string;
+    meta?: string;
+}
+export interface CommentThreadItem {
+    id: string | number;
+    author: CommentThreadAuthor;
+    body: string;
+    createdAt?: DateLike;
+    resolved?: boolean;
+    parentId?: string | number | null;
+}
+interface Props {
+    items?: Array<CommentThreadItem>;
+    ariaLabel?: string;
+    emptyText?: string;
+    replyLabel?: string;
+    cancelReplyLabel?: string;
+    sendReplyLabel?: string;
+    replyPlaceholder?: string;
+    replyAriaLabel?: string;
+    resolveLabel?: string;
+    reopenLabel?: string;
+    locale?: string;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    reply: (payload: {
+        parent: CommentThreadItem;
+        index: number;
+        text: string;
+        mentions: Array<string>;
+    }) => any;
+    resolve: (payload: {
+        item: CommentThreadItem;
+        index: number;
+    }) => any;
+    reopen: (payload: {
+        item: CommentThreadItem;
+        index: number;
+    }) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onReply?: ((payload: {
+        parent: CommentThreadItem;
+        index: number;
+        text: string;
+        mentions: Array<string>;
+    }) => any) | undefined;
+    onResolve?: ((payload: {
+        item: CommentThreadItem;
+        index: number;
+    }) => any) | undefined;
+    onReopen?: ((payload: {
+        item: CommentThreadItem;
+        index: number;
+    }) => any) | undefined;
+}>, {
+    ariaLabel: string;
+    items: Array<CommentThreadItem>;
+    emptyText: string;
+    locale: string;
+    replyLabel: string;
+    cancelReplyLabel: string;
+    sendReplyLabel: string;
+    replyPlaceholder: string;
+    replyAriaLabel: string;
+    resolveLabel: string;
+    reopenLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/package/components/confirm-dialog.vue.d.ts

@@ -68,8 +68,8 @@ declare function __VLS_template(): {
                 open: (...args: any[]) => void;
             }, string, {
                 title: string;
-                size: "sm" | "md" | "lg";
                 modelValue: boolean;
+                size: "sm" | "md" | "lg";
                 closeOnOverlay: boolean;
                 closeOnEsc: boolean;
                 showClose: boolean;
@@ -96,8 +96,8 @@ declare function __VLS_template(): {
             $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
         } & Readonly<{
             title: string;
-            size: "sm" | "md" | "lg";
             modelValue: boolean;
+            size: "sm" | "md" | "lg";
             closeOnOverlay: boolean;
             closeOnEsc: boolean;
             showClose: boolean;
@@ -106,7 +106,7 @@ declare function __VLS_template(): {
             onClose?: ((...args: any[]) => any) | undefined;
             "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
             onOpen?: ((...args: any[]) => any) | undefined;
-        }>, "close" | "open" | ("title" | "size" | "modelValue" | "closeOnOverlay" | "closeOnEsc" | "showClose" | "lockScroll")> & import('vue').ShallowUnwrapRef<{
+        }>, "close" | "open" | ("title" | "modelValue" | "size" | "closeOnOverlay" | "closeOnEsc" | "showClose" | "lockScroll")> & import('vue').ShallowUnwrapRef<{
             open: () => void;
             close: () => void;
         }> & {} & import('vue').ComponentCustomProperties & {} & {
@@ -141,15 +141,15 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
     onConfirm?: ((...args: any[]) => any) | undefined;
 }>, {
     title: string;
-    size: "sm" | "md" | "lg";
     modelValue: boolean;
+    size: "sm" | "md" | "lg";
     loading: boolean;
     cancelLabel: string;
     closeOnOverlay: boolean;
-    message: string;
     closeOnEsc: boolean;
     showClose: boolean;
     lockScroll: boolean;
+    message: string;
     confirmLabel: string;
     confirmSeverity: ButtonSeverity;
     closeOnConfirm: boolean;
@@ -198,8 +198,8 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
             open: (...args: any[]) => void;
         }, string, {
             title: string;
-            size: "sm" | "md" | "lg";
             modelValue: boolean;
+            size: "sm" | "md" | "lg";
             closeOnOverlay: boolean;
             closeOnEsc: boolean;
             showClose: boolean;
@@ -226,8 +226,8 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
         $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
     } & Readonly<{
         title: string;
-        size: "sm" | "md" | "lg";
         modelValue: boolean;
+        size: "sm" | "md" | "lg";
         closeOnOverlay: boolean;
         closeOnEsc: boolean;
         showClose: boolean;
@@ -236,7 +236,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {
         onClose?: ((...args: any[]) => any) | undefined;
         "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
         onOpen?: ((...args: any[]) => any) | undefined;
-    }>, "close" | "open" | ("title" | "size" | "modelValue" | "closeOnOverlay" | "closeOnEsc" | "showClose" | "lockScroll")> & import('vue').ShallowUnwrapRef<{
+    }>, "close" | "open" | ("title" | "modelValue" | "size" | "closeOnOverlay" | "closeOnEsc" | "showClose" | "lockScroll")> & import('vue').ShallowUnwrapRef<{
         open: () => void;
         close: () => void;
     }> & {} & import('vue').ComponentCustomProperties & {} & {