vue-editify 0.2.17 → 0.2.19

package/lib/editify/editify.vue.d.ts

@@ -107,10 +107,6 @@ declare const _default: import('vue').DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-    tab: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     dark: {
         type: BooleanConstructor;
         default: boolean;
@@ -287,11 +283,156 @@ declare const _default: import('vue').DefineComponent<{
                     };
                 } | null;
             }[];
-            current: number;
-            push: (stack: AlexElement[], range?: import('alex-editor').AlexRange | null) => void;
-            get: (type: -1 | 1) => import('alex-editor').AlexHistoryResultType | null;
-            updateCurrentRange: (range: import('alex-editor').AlexRange) => void;
-            __cloneRange: (newStack: AlexElement[], range?: import('alex-editor').AlexRange | null) => import('alex-editor').AlexRange | null;
+            redoRecords: {
+                stack: {
+                    key: number;
+                    type: import('alex-editor').AlexElementType;
+                    parsedom: string | null;
+                    marks: import('alex-editor').ObjectType | null;
+                    styles: import('alex-editor').ObjectType | null;
+                    textContent: string | null;
+                    children: any[] | null;
+                    parent: any | null;
+                    behavior: "default" | "block";
+                    namespace: string | null;
+                    locked: boolean;
+                    elm: HTMLElement | null;
+                    isBlock: () => boolean;
+                    isInblock: () => boolean;
+                    isInline: () => boolean;
+                    isClosed: () => boolean;
+                    isText: () => boolean;
+                    isBreak: () => boolean;
+                    isEmpty: () => boolean;
+                    isSpaceText: () => boolean;
+                    getUneditableElement: () => AlexElement | null;
+                    isEqual: (element: AlexElement) => boolean;
+                    isContains: (element: AlexElement) => boolean;
+                    isOnlyHasBreak: () => boolean | 0;
+                    isPreStyle: () => boolean;
+                    hasMarks: () => boolean;
+                    hasStyles: () => boolean;
+                    hasChildren: () => boolean;
+                    hasContains: (element: AlexElement) => boolean;
+                    clone: (deep?: boolean | undefined) => AlexElement;
+                    convertToBlock: () => void;
+                    toEmpty: () => void;
+                    getBlock: () => AlexElement;
+                    getInblock: () => AlexElement | null;
+                    getInline: () => AlexElement | null;
+                    isEqualStyles: (element: AlexElement) => boolean;
+                    isEqualMarks: (element: AlexElement) => boolean;
+                    isFirst: (element: AlexElement) => boolean;
+                    isLast: (element: AlexElement) => boolean;
+                    __render: () => void;
+                    __fullClone: () => AlexElement;
+                }[];
+                range: {
+                    anchor: {
+                        element: {
+                            key: number;
+                            type: import('alex-editor').AlexElementType;
+                            parsedom: string | null;
+                            marks: import('alex-editor').ObjectType | null;
+                            styles: import('alex-editor').ObjectType | null;
+                            textContent: string | null;
+                            children: any[] | null;
+                            parent: any | null;
+                            behavior: "default" | "block";
+                            namespace: string | null;
+                            locked: boolean;
+                            elm: HTMLElement | null;
+                            isBlock: () => boolean;
+                            isInblock: () => boolean;
+                            isInline: () => boolean;
+                            isClosed: () => boolean;
+                            isText: () => boolean;
+                            isBreak: () => boolean;
+                            isEmpty: () => boolean;
+                            isSpaceText: () => boolean;
+                            getUneditableElement: () => AlexElement | null;
+                            isEqual: (element: AlexElement) => boolean;
+                            isContains: (element: AlexElement) => boolean;
+                            isOnlyHasBreak: () => boolean | 0;
+                            isPreStyle: () => boolean;
+                            hasMarks: () => boolean;
+                            hasStyles: () => boolean;
+                            hasChildren: () => boolean;
+                            hasContains: (element: AlexElement) => boolean;
+                            clone: (deep?: boolean | undefined) => AlexElement;
+                            convertToBlock: () => void;
+                            toEmpty: () => void;
+                            getBlock: () => AlexElement;
+                            getInblock: () => AlexElement | null;
+                            getInline: () => AlexElement | null;
+                            isEqualStyles: (element: AlexElement) => boolean;
+                            isEqualMarks: (element: AlexElement) => boolean;
+                            isFirst: (element: AlexElement) => boolean;
+                            isLast: (element: AlexElement) => boolean;
+                            __render: () => void;
+                            __fullClone: () => AlexElement;
+                        };
+                        offset: number;
+                        isEqual: (point: import('alex-editor').AlexPoint) => boolean;
+                        moveToEnd: (element: AlexElement) => void;
+                        moveToStart: (element: AlexElement) => void;
+                    };
+                    focus: {
+                        element: {
+                            key: number;
+                            type: import('alex-editor').AlexElementType;
+                            parsedom: string | null;
+                            marks: import('alex-editor').ObjectType | null;
+                            styles: import('alex-editor').ObjectType | null;
+                            textContent: string | null;
+                            children: any[] | null;
+                            parent: any | null;
+                            behavior: "default" | "block";
+                            namespace: string | null;
+                            locked: boolean;
+                            elm: HTMLElement | null;
+                            isBlock: () => boolean;
+                            isInblock: () => boolean;
+                            isInline: () => boolean;
+                            isClosed: () => boolean;
+                            isText: () => boolean;
+                            isBreak: () => boolean;
+                            isEmpty: () => boolean;
+                            isSpaceText: () => boolean;
+                            getUneditableElement: () => AlexElement | null;
+                            isEqual: (element: AlexElement) => boolean;
+                            isContains: (element: AlexElement) => boolean;
+                            isOnlyHasBreak: () => boolean | 0;
+                            isPreStyle: () => boolean;
+                            hasMarks: () => boolean;
+                            hasStyles: () => boolean;
+                            hasChildren: () => boolean;
+                            hasContains: (element: AlexElement) => boolean;
+                            clone: (deep?: boolean | undefined) => AlexElement;
+                            convertToBlock: () => void;
+                            toEmpty: () => void;
+                            getBlock: () => AlexElement;
+                            getInblock: () => AlexElement | null;
+                            getInline: () => AlexElement | null;
+                            isEqualStyles: (element: AlexElement) => boolean;
+                            isEqualMarks: (element: AlexElement) => boolean;
+                            isFirst: (element: AlexElement) => boolean;
+                            isLast: (element: AlexElement) => boolean;
+                            __render: () => void;
+                            __fullClone: () => AlexElement;
+                        };
+                        offset: number;
+                        isEqual: (point: import('alex-editor').AlexPoint) => boolean;
+                        moveToEnd: (element: AlexElement) => void;
+                        moveToStart: (element: AlexElement) => void;
+                    };
+                } | null;
+            }[];
+            cloneRange: (newStack: AlexElement[], range: import('alex-editor').AlexRange | null) => import('alex-editor').AlexRange | null;
+            setState: (stack: AlexElement[], range: import('alex-editor').AlexRange | null) => void;
+            undo: () => import('alex-editor').AlexHistoryRecordType | null;
+            redo: () => import('alex-editor').AlexHistoryRecordType | null;
+            updateRange: (range: import('alex-editor').AlexRange) => void;
         };
         stack: {
             key: number;
@@ -437,7 +578,9 @@ declare const _default: import('vue').DefineComponent<{
             };
         } | null;
         __guid: number;
-        __events: import('alex-editor').ObjectType;
+        __events: {
+            [key: string]: ((...args: any) => void)[];
+        };
         __oldStack: {
             key: number;
             type: import('alex-editor').AlexElementType;
@@ -484,6 +627,12 @@ declare const _default: import('vue').DefineComponent<{
         __isInputChinese: boolean;
         __innerSelectionChange: boolean;
         __chineseInputTimer: any;
+        __domObserver: {
+            disconnect: () => void;
+            observe: (target: Node, options?: MutationObserverInit) => void;
+            takeRecords: () => MutationRecord[];
+        } | null;
+        __illegalDoms: Node[];
         initRange: () => void;
         delete: () => void;
         insertText: (data: string) => void;
@@ -507,8 +656,11 @@ declare const _default: import('vue').DefineComponent<{
         collapseToEnd: (element?: AlexElement) => void;
         setDisabled: () => void;
         setEnabled: () => void;
+        undo: () => void;
+        redo: () => void;
         emit: (eventName: string, ...value: any) => boolean;
         on: (eventName: string, eventHandle: (...args: any) => void) => void;
+        off: (eventName: string, eventHandle?: (...args: any) => void) => void;
         destroy: () => void;
     } | null>;
     isSourceView: import('vue').Ref<boolean>;
@@ -730,10 +882,6 @@ declare const _default: import('vue').DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-    tab: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     dark: {
         type: BooleanConstructor;
         default: boolean;
@@ -784,7 +932,6 @@ declare const _default: import('vue').DefineComponent<{
     extraKeepTags: string[];
     renderRules: ((el: AlexElement) => void)[];
     autoheight: boolean;
-    tab: boolean;
     dark: boolean;
     offset: number;
 }, {}>;

package/lib/editify/props.d.ts

@@ -10,7 +10,7 @@ export type EditifyResizeParamsType = {
 export type EditifyToolbarOptionsType = {
     show: boolean;
     node: string | null;
-    type: 'text' | 'link' | 'image' | 'video' | 'table' | 'codeBlock';
+    type: 'text' | 'link' | 'image' | 'video' | 'table' | 'codeBlock' | 'orderList' | 'unorderList';
 };
 export declare const EditifyProps: {
     locale: {
@@ -118,10 +118,6 @@ export declare const EditifyProps: {
         type: BooleanConstructor;
         default: boolean;
     };
-    tab: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     dark: {
         type: BooleanConstructor;
         default: boolean;

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

@@ -15,7 +15,7 @@ export declare const ToolbarProps: {
         default: null;
     };
     type: {
-        type: PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video">;
+        type: PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video" | "orderList" | "unorderList">;
         default: string;
         validator(value: any): boolean;
     };

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

@@ -14,7 +14,7 @@ declare const _default: import('vue').DefineComponent<{
         default: null;
     };
     type: {
-        type: import('vue').PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video">;
+        type: import('vue').PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video" | "orderList" | "unorderList">;
         default: string;
         validator(value: any): boolean;
     };
@@ -326,7 +326,7 @@ declare const _default: import('vue').DefineComponent<{
         default: null;
     };
     type: {
-        type: import('vue').PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video">;
+        type: import('vue').PropType<"text" | "table" | "link" | "codeBlock" | "image" | "video" | "orderList" | "unorderList">;
         default: string;
         validator(value: any): boolean;
     };
@@ -345,7 +345,7 @@ declare const _default: import('vue').DefineComponent<{
 }>> & {
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }, {
-    type: "text" | "link" | "table" | "video" | "image" | "codeBlock";
+    type: "text" | "orderList" | "unorderList" | "link" | "table" | "video" | "image" | "codeBlock";
     color: string;
     zIndex: number;
     modelValue: boolean;