vue-editify 0.1.10 → 0.1.13

package/lib/components/insertLink/insertLink.vue.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import('vue').DefineComponent<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    insert: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onInsert?: ((...args: any[]) => any) | undefined;
+}, {
+    color: string;
+    text: string;
+}, {}>;
+export default _default;

package/lib/components/insertLink/props.d.ts

@@ -0,0 +1,13 @@
+import { ExtractPublicPropTypes } from 'vue';
+
+export declare const InsertLinkProps: {
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type InsertLinkPropsType = ExtractPublicPropTypes<typeof InsertLinkProps>;

package/lib/components/insertTable/insertTable.vue.d.ts

@@ -0,0 +1,36 @@
+declare const _default: import('vue').DefineComponent<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxColumns: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    insert: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxColumns: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & {
+    onInsert?: ((...args: any[]) => any) | undefined;
+}, {
+    color: string;
+    maxRows: number;
+    maxColumns: number;
+}, {}>;
+export default _default;

package/lib/components/insertTable/props.d.ts

@@ -0,0 +1,22 @@
+import { ExtractPublicPropTypes } from 'vue';
+
+export type InsertTableGridType = {
+    x: number;
+    y: number;
+    inside: boolean;
+};
+export declare const InsertTableProps: {
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxRows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxColumns: {
+        type: NumberConstructor;
+        default: number;
+    };
+};
+export type InsertTablePropsType = ExtractPublicPropTypes<typeof InsertTableProps>;

package/lib/components/insertVideo/insertVideo.vue.d.ts

@@ -0,0 +1,74 @@
+declare const _default: import('vue').DefineComponent<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string[]>;
+        default: null;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    minSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    customUpload: {
+        type: import("vue").PropType<(files: File[]) => string[] | Promise<string[]>>;
+        default: null;
+    };
+    handleError: {
+        type: import("vue").PropType<(error: import("./props").InsertVideoUploadErrorType, file: File) => void>;
+        default: null;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    insert: (...args: any[]) => void;
+    change: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: import("vue").PropType<string[]>;
+        default: null;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    minSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    customUpload: {
+        type: import("vue").PropType<(files: File[]) => string[] | Promise<string[]>>;
+        default: null;
+    };
+    handleError: {
+        type: import("vue").PropType<(error: import("./props").InsertVideoUploadErrorType, file: File) => void>;
+        default: null;
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    onInsert?: ((...args: any[]) => any) | undefined;
+}, {
+    color: string;
+    accept: string[];
+    multiple: boolean;
+    maxSize: number;
+    minSize: number;
+    customUpload: (files: File[]) => string[] | Promise<string[]>;
+    handleError: (error: import("./props").InsertVideoUploadErrorType, file: File) => void;
+}, {}>;
+export default _default;

package/lib/components/insertVideo/props.d.ts

@@ -0,0 +1,34 @@
+import { ExtractPublicPropTypes, PropType } from 'vue';
+
+export type InsertVideoUploadErrorType = 'suffixError' | 'maxSizeError' | 'minSizeError';
+export declare const InsertVideoProps: {
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    accept: {
+        type: PropType<string[]>;
+        default: null;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    minSize: {
+        type: NumberConstructor;
+        default: null;
+    };
+    customUpload: {
+        type: PropType<(files: File[]) => string[] | Promise<string[]>>;
+        default: null;
+    };
+    handleError: {
+        type: PropType<(error: InsertVideoUploadErrorType, file: File) => void>;
+        default: null;
+    };
+};
+export type InsertVideoPropsType = ExtractPublicPropTypes<typeof InsertVideoProps>;

package/lib/components/layer/layer.vue.d.ts

@@ -0,0 +1,129 @@
+import { LayerPlacementType } from './props';
+
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: import("vue").PropType<string | HTMLElement | null>;
+        default: null;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    borderColor: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    placement: {
+        type: import("vue").PropType<LayerPlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    showTriangle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animation: {
+        type: import("vue").PropType<import("./props").LayerAnimationType>;
+        default: null;
+        validator(value: any): boolean;
+    };
+    useRange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    setPosition: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    show: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    shown: (...args: any[]) => void;
+    hidden: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: import("vue").PropType<string | HTMLElement | null>;
+        default: null;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    borderColor: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    placement: {
+        type: import("vue").PropType<LayerPlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    showTriangle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animation: {
+        type: import("vue").PropType<import("./props").LayerAnimationType>;
+        default: null;
+        validator(value: any): boolean;
+    };
+    useRange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    onShow?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onShown?: ((...args: any[]) => any) | undefined;
+    onHidden?: ((...args: any[]) => any) | undefined;
+}, {
+    placement: LayerPlacementType;
+    color: string;
+    background: string;
+    modelValue: boolean;
+    node: string | HTMLElement | null;
+    border: boolean;
+    borderColor: string;
+    showTriangle: boolean;
+    zIndex: number;
+    animation: import("./props").LayerAnimationType;
+    useRange: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/layer/props.d.ts

@@ -0,0 +1,53 @@
+import { ExtractPublicPropTypes, PropType } from 'vue';
+
+export type LayerPlacementType = 'top' | 'bottom' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+export type LayerAnimationType = 'translate' | 'fade' | null;
+export declare const LayerProps: {
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: PropType<string | HTMLElement | null>;
+        default: null;
+    };
+    border: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    borderColor: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    placement: {
+        type: PropType<LayerPlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    showTriangle: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    zIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    animation: {
+        type: PropType<LayerAnimationType>;
+        default: null;
+        validator(value: any): boolean;
+    };
+    useRange: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type LayerPropsType = ExtractPublicPropTypes<typeof LayerProps>;

package/lib/components/menu/menu.vue.d.ts

@@ -0,0 +1,25 @@
+declare const _default: import('vue').DefineComponent<{
+    config: {
+        type: import("vue").PropType<import("../../core/tool").MenuConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    handleRangeUpdate: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    config: {
+        type: import("vue").PropType<import("../../core/tool").MenuConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    color: string;
+    config: import("../../core/tool").MenuConfigType;
+}, {}>;
+export default _default;

package/lib/components/menu/props.d.ts

@@ -0,0 +1,14 @@
+import { MenuConfigType } from '../../core/tool';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+
+export declare const MenuProps: {
+    config: {
+        type: PropType<MenuConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type MenuPropsType = ExtractPublicPropTypes<typeof MenuProps>;

package/lib/components/toolbar/props.d.ts

@@ -0,0 +1,27 @@
+import { ToolbarConfigType } from '../../core/tool';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+
+export declare const ToolbarProps: {
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: PropType<string | HTMLElement>;
+        default: null;
+    };
+    type: {
+        type: PropType<"link" | "text" | "image" | "video" | "table" | "codeBlock">;
+        default: string;
+        validator(value: any): boolean;
+    };
+    config: {
+        type: PropType<ToolbarConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+};
+export type ToolbarPropsType = ExtractPublicPropTypes<typeof ToolbarProps>;

package/lib/components/toolbar/toolbar.vue.d.ts

@@ -0,0 +1,56 @@
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: import("vue").PropType<string | HTMLElement>;
+        default: null;
+    };
+    type: {
+        type: import("vue").PropType<"link" | "text" | "image" | "video" | "table" | "codeBlock">;
+        default: string;
+        validator(value: any): boolean;
+    };
+    config: {
+        type: import("vue").PropType<import("../..").ToolbarConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    node: {
+        type: import("vue").PropType<string | HTMLElement>;
+        default: null;
+    };
+    type: {
+        type: import("vue").PropType<"link" | "text" | "image" | "video" | "table" | "codeBlock">;
+        default: string;
+        validator(value: any): boolean;
+    };
+    config: {
+        type: import("vue").PropType<import("../..").ToolbarConfigType>;
+        default: null;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    color: string;
+    type: "link" | "text" | "image" | "video" | "table" | "codeBlock";
+    modelValue: boolean;
+    node: string | HTMLElement;
+    config: import("../..").ToolbarConfigType;
+}, {}>;
+export default _default;

package/lib/components/tooltip/props.d.ts

@@ -0,0 +1,17 @@
+import { ExtractPublicPropTypes } from 'vue';
+
+export declare const TooltipProps: {
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export type TooltipPropsType = ExtractPublicPropTypes<typeof TooltipProps>;

package/lib/components/tooltip/tooltip.vue.d.ts

@@ -0,0 +1,39 @@
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    content: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+    content: string;
+    block: boolean;
+}, {}>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/triangle/props.d.ts

@@ -0,0 +1,19 @@
+import { ExtractPublicPropTypes, PropType } from 'vue';
+
+export type TrianglePlacementType = 'top' | 'left' | 'right' | 'bottom';
+export declare const TriangleProps: {
+    placement: {
+        type: PropType<TrianglePlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+};
+export type TrianglePropsType = ExtractPublicPropTypes<typeof TriangleProps>;

package/lib/components/triangle/triangle.vue.d.ts

@@ -0,0 +1,34 @@
+declare const _default: import('vue').DefineComponent<{
+    placement: {
+        type: import("vue").PropType<import("./props").TrianglePlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    placement: {
+        type: import("vue").PropType<import("./props").TrianglePlacementType>;
+        default: string;
+        validator(value: any): boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: null;
+    };
+    background: {
+        type: StringConstructor;
+        default: null;
+    };
+}>>, {
+    placement: import("./props").TrianglePlacementType;
+    color: string;
+    background: string;
+}, {}>;
+export default _default;

package/lib/core/function.d.ts

@@ -0,0 +1,45 @@
+import { ObjectType } from './tool';
+import { AlexElement, AlexElementsRangeType, AlexEditor } from 'alex-editor';
+
+export declare const getParsedomElementByElement: (element: AlexElement, parsedom: string) => AlexElement | null;
+export declare const getCurrentParsedomElement: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, parsedom: string) => AlexElement | null;
+export declare const elementIsInList: (element: AlexElement, ordered: boolean) => boolean;
+export declare const elementIsInTask: (element: AlexElement) => boolean;
+export declare const isList: (element: AlexElement, ordered?: boolean | undefined) => boolean;
+export declare const isTask: (element: AlexElement) => boolean;
+export declare const hasPreInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const isRangeInPre: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasQuoteInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const isRangeInQuote: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasListInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, ordered?: boolean | undefined) => boolean;
+export declare const isRangeInList: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, ordered?: boolean | undefined) => boolean;
+export declare const hasTaskInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const isRangeInTask: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasLinkInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasTableInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasImageInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const hasVideoInRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => boolean;
+export declare const queryTextStyle: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => boolean;
+export declare const queryTextMark: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, name: string, value?: string | number) => boolean;
+export declare const getRangeText: (dataRangeCaches: AlexElementsRangeType) => string;
+export declare const getFlatElementsByRange: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => AlexElement[];
+export declare const elementToParagraph: (element: AlexElement) => void;
+export declare const elementToList: (element: AlexElement, ordered?: boolean | undefined) => void;
+export declare const elementToTask: (element: AlexElement) => void;
+export declare const setHeading: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, editTrans: (key: string) => any, parsedom: string) => void;
+export declare const setIndentIncrease: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => void;
+export declare const setIndentDecrease: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => void;
+export declare const setQuote: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => void;
+export declare const setAlign: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, value: string) => void;
+export declare const setList: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, ordered: boolean) => void;
+export declare const setTask: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => void;
+export declare const setTextStyle: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styles: ObjectType) => void;
+export declare const setTextMark: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, marks: ObjectType) => void;
+export declare const removeTextStyle: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, styleNames?: string[]) => void;
+export declare const removeTextMark: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, markNames?: string[]) => void;
+export declare const setLineHeight: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType, value: string | number) => void;
+export declare const insertLink: (editor: AlexEditor, text: string, url: string, newOpen: boolean) => void;
+export declare const insertImage: (editor: AlexEditor, value: string) => void;
+export declare const insertVideo: (editor: AlexEditor, value: string) => void;
+export declare const insertTable: (editor: AlexEditor, rowLength: number, colLength: number) => void;
+export declare const insertCodeBlock: (editor: AlexEditor, dataRangeCaches: AlexElementsRangeType) => void;