vue-editify 0.2.8 → 0.2.10
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/examples/App.vue +11 -6
- package/lib/components/button/button.vue.d.ts +271 -0
- package/lib/components/button/props.d.ts +4 -0
- package/lib/components/checkbox/checkbox.vue.d.ts +2 -2
- package/lib/components/layer/layer.vue.d.ts +12 -3
- package/lib/components/layer/props.d.ts +4 -0
- package/lib/components/menu/menu.vue.d.ts +12 -0
- package/lib/components/menu/props.d.ts +4 -0
- package/lib/components/toolbar/props.d.ts +8 -0
- package/lib/components/toolbar/toolbar.vue.d.ts +18 -0
- package/lib/components/tooltip/props.d.ts +4 -0
- package/lib/components/tooltip/tooltip.vue.d.ts +9 -0
- package/lib/core/tool.d.ts +7 -0
- package/lib/editify/editify.vue.d.ts +89 -28
- package/lib/editify/props.d.ts +8 -0
- package/lib/editify.es.js +472 -382
- package/lib/editify.umd.js +2 -2
- package/lib/hljs/index.d.ts +7 -4
- package/lib/index.d.ts +90 -29
- package/package.json +6 -6
- package/src/components/button/button.less +48 -48
- package/src/components/button/button.vue +4 -3
- package/src/components/button/props.ts +5 -0
- package/src/components/layer/layer.less +1 -1
- package/src/components/layer/layer.vue +111 -84
- package/src/components/layer/props.ts +6 -1
- package/src/components/menu/menu.less +0 -1
- package/src/components/menu/menu.vue +46 -70
- package/src/components/menu/props.ts +5 -0
- package/src/components/toolbar/props.ts +10 -0
- package/src/components/toolbar/toolbar.vue +49 -49
- package/src/components/tooltip/props.ts +5 -0
- package/src/components/tooltip/tooltip.less +7 -15
- package/src/components/tooltip/tooltip.vue +5 -7
- package/src/core/tool.ts +27 -1
- package/src/editify/editify.less +0 -5
- package/src/editify/editify.vue +10 -6
- package/src/editify/props.ts +10 -0
- package/src/hljs/index.ts +34 -28
- package/src/index.ts +1 -1
| @@ -119,6 +119,14 @@ declare const _default: import('vue').DefineComponent<{ | |
| 119 119 | 
             
                    type: BooleanConstructor;
         | 
| 120 120 | 
             
                    default: boolean;
         | 
| 121 121 | 
             
                };
         | 
| 122 | 
            +
                zIndex: {
         | 
| 123 | 
            +
                    type: NumberConstructor;
         | 
| 124 | 
            +
                    default: number;
         | 
| 125 | 
            +
                };
         | 
| 126 | 
            +
                offset: {
         | 
| 127 | 
            +
                    type: NumberConstructor;
         | 
| 128 | 
            +
                    default: number;
         | 
| 129 | 
            +
                };
         | 
| 122 130 | 
             
            }, {
         | 
| 123 131 | 
             
                editor: import('vue').Ref<{
         | 
| 124 132 | 
             
                    $el: HTMLElement;
         | 
| @@ -143,8 +151,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 143 151 | 
             
                                key: number;
         | 
| 144 152 | 
             
                                type: import('alex-editor').AlexElementType;
         | 
| 145 153 | 
             
                                parsedom: string | null;
         | 
| 146 | 
            -
                                marks: import('alex-editor | 
| 147 | 
            -
                                styles: import('alex-editor | 
| 154 | 
            +
                                marks: import('alex-editor').ObjectType | null;
         | 
| 155 | 
            +
                                styles: import('alex-editor').ObjectType | null;
         | 
| 148 156 | 
             
                                textContent: string | null;
         | 
| 149 157 | 
             
                                children: any[] | null;
         | 
| 150 158 | 
             
                                parent: any | null;
         | 
| @@ -163,7 +171,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 163 171 | 
             
                                getUneditableElement: () => AlexElement | null;
         | 
| 164 172 | 
             
                                isEqual: (element: AlexElement) => boolean;
         | 
| 165 173 | 
             
                                isContains: (element: AlexElement) => boolean;
         | 
| 166 | 
            -
                                isOnlyHasBreak: () => boolean;
         | 
| 174 | 
            +
                                isOnlyHasBreak: () => boolean | 0;
         | 
| 167 175 | 
             
                                isPreStyle: () => boolean;
         | 
| 168 176 | 
             
                                hasMarks: () => boolean;
         | 
| 169 177 | 
             
                                hasStyles: () => boolean;
         | 
| @@ -188,8 +196,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 188 196 | 
             
                                        key: number;
         | 
| 189 197 | 
             
                                        type: import('alex-editor').AlexElementType;
         | 
| 190 198 | 
             
                                        parsedom: string | null;
         | 
| 191 | 
            -
                                        marks: import('alex-editor | 
| 192 | 
            -
                                        styles: import('alex-editor | 
| 199 | 
            +
                                        marks: import('alex-editor').ObjectType | null;
         | 
| 200 | 
            +
                                        styles: import('alex-editor').ObjectType | null;
         | 
| 193 201 | 
             
                                        textContent: string | null;
         | 
| 194 202 | 
             
                                        children: any[] | null;
         | 
| 195 203 | 
             
                                        parent: any | null;
         | 
| @@ -208,7 +216,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 208 216 | 
             
                                        getUneditableElement: () => AlexElement | null;
         | 
| 209 217 | 
             
                                        isEqual: (element: AlexElement) => boolean;
         | 
| 210 218 | 
             
                                        isContains: (element: AlexElement) => boolean;
         | 
| 211 | 
            -
                                        isOnlyHasBreak: () => boolean;
         | 
| 219 | 
            +
                                        isOnlyHasBreak: () => boolean | 0;
         | 
| 212 220 | 
             
                                        isPreStyle: () => boolean;
         | 
| 213 221 | 
             
                                        hasMarks: () => boolean;
         | 
| 214 222 | 
             
                                        hasStyles: () => boolean;
         | 
| @@ -237,8 +245,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 237 245 | 
             
                                        key: number;
         | 
| 238 246 | 
             
                                        type: import('alex-editor').AlexElementType;
         | 
| 239 247 | 
             
                                        parsedom: string | null;
         | 
| 240 | 
            -
                                        marks: import('alex-editor | 
| 241 | 
            -
                                        styles: import('alex-editor | 
| 248 | 
            +
                                        marks: import('alex-editor').ObjectType | null;
         | 
| 249 | 
            +
                                        styles: import('alex-editor').ObjectType | null;
         | 
| 242 250 | 
             
                                        textContent: string | null;
         | 
| 243 251 | 
             
                                        children: any[] | null;
         | 
| 244 252 | 
             
                                        parent: any | null;
         | 
| @@ -257,7 +265,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 257 265 | 
             
                                        getUneditableElement: () => AlexElement | null;
         | 
| 258 266 | 
             
                                        isEqual: (element: AlexElement) => boolean;
         | 
| 259 267 | 
             
                                        isContains: (element: AlexElement) => boolean;
         | 
| 260 | 
            -
                                        isOnlyHasBreak: () => boolean;
         | 
| 268 | 
            +
                                        isOnlyHasBreak: () => boolean | 0;
         | 
| 261 269 | 
             
                                        isPreStyle: () => boolean;
         | 
| 262 270 | 
             
                                        hasMarks: () => boolean;
         | 
| 263 271 | 
             
                                        hasStyles: () => boolean;
         | 
| @@ -293,8 +301,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 293 301 | 
             
                        key: number;
         | 
| 294 302 | 
             
                        type: import('alex-editor').AlexElementType;
         | 
| 295 303 | 
             
                        parsedom: string | null;
         | 
| 296 | 
            -
                        marks: import('alex-editor | 
| 297 | 
            -
                        styles: import('alex-editor | 
| 304 | 
            +
                        marks: import('alex-editor').ObjectType | null;
         | 
| 305 | 
            +
                        styles: import('alex-editor').ObjectType | null;
         | 
| 298 306 | 
             
                        textContent: string | null;
         | 
| 299 307 | 
             
                        children: any[] | null;
         | 
| 300 308 | 
             
                        parent: any | null;
         | 
| @@ -313,7 +321,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 313 321 | 
             
                        getUneditableElement: () => AlexElement | null;
         | 
| 314 322 | 
             
                        isEqual: (element: AlexElement) => boolean;
         | 
| 315 323 | 
             
                        isContains: (element: AlexElement) => boolean;
         | 
| 316 | 
            -
                        isOnlyHasBreak: () => boolean;
         | 
| 324 | 
            +
                        isOnlyHasBreak: () => boolean | 0;
         | 
| 317 325 | 
             
                        isPreStyle: () => boolean;
         | 
| 318 326 | 
             
                        hasMarks: () => boolean;
         | 
| 319 327 | 
             
                        hasStyles: () => boolean;
         | 
| @@ -338,8 +346,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 338 346 | 
             
                                key: number;
         | 
| 339 347 | 
             
                                type: import('alex-editor').AlexElementType;
         | 
| 340 348 | 
             
                                parsedom: string | null;
         | 
| 341 | 
            -
                                marks: import('alex-editor | 
| 342 | 
            -
                                styles: import('alex-editor | 
| 349 | 
            +
                                marks: import('alex-editor').ObjectType | null;
         | 
| 350 | 
            +
                                styles: import('alex-editor').ObjectType | null;
         | 
| 343 351 | 
             
                                textContent: string | null;
         | 
| 344 352 | 
             
                                children: any[] | null;
         | 
| 345 353 | 
             
                                parent: any | null;
         | 
| @@ -358,7 +366,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 358 366 | 
             
                                getUneditableElement: () => AlexElement | null;
         | 
| 359 367 | 
             
                                isEqual: (element: AlexElement) => boolean;
         | 
| 360 368 | 
             
                                isContains: (element: AlexElement) => boolean;
         | 
| 361 | 
            -
                                isOnlyHasBreak: () => boolean;
         | 
| 369 | 
            +
                                isOnlyHasBreak: () => boolean | 0;
         | 
| 362 370 | 
             
                                isPreStyle: () => boolean;
         | 
| 363 371 | 
             
                                hasMarks: () => boolean;
         | 
| 364 372 | 
             
                                hasStyles: () => boolean;
         | 
| @@ -387,8 +395,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 387 395 | 
             
                                key: number;
         | 
| 388 396 | 
             
                                type: import('alex-editor').AlexElementType;
         | 
| 389 397 | 
             
                                parsedom: string | null;
         | 
| 390 | 
            -
                                marks: import('alex-editor | 
| 391 | 
            -
                                styles: import('alex-editor | 
| 398 | 
            +
                                marks: import('alex-editor').ObjectType | null;
         | 
| 399 | 
            +
                                styles: import('alex-editor').ObjectType | null;
         | 
| 392 400 | 
             
                                textContent: string | null;
         | 
| 393 401 | 
             
                                children: any[] | null;
         | 
| 394 402 | 
             
                                parent: any | null;
         | 
| @@ -407,7 +415,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 407 415 | 
             
                                getUneditableElement: () => AlexElement | null;
         | 
| 408 416 | 
             
                                isEqual: (element: AlexElement) => boolean;
         | 
| 409 417 | 
             
                                isContains: (element: AlexElement) => boolean;
         | 
| 410 | 
            -
                                isOnlyHasBreak: () => boolean;
         | 
| 418 | 
            +
                                isOnlyHasBreak: () => boolean | 0;
         | 
| 411 419 | 
             
                                isPreStyle: () => boolean;
         | 
| 412 420 | 
             
                                hasMarks: () => boolean;
         | 
| 413 421 | 
             
                                hasStyles: () => boolean;
         | 
| @@ -433,8 +441,50 @@ declare const _default: import('vue').DefineComponent<{ | |
| 433 441 | 
             
                        };
         | 
| 434 442 | 
             
                    } | null;
         | 
| 435 443 | 
             
                    __guid: number;
         | 
| 436 | 
            -
                    __events: import('alex-editor | 
| 437 | 
            -
                     | 
| 444 | 
            +
                    __events: import('alex-editor').ObjectType;
         | 
| 445 | 
            +
                    __oldStack: {
         | 
| 446 | 
            +
                        key: number;
         | 
| 447 | 
            +
                        type: import('alex-editor').AlexElementType;
         | 
| 448 | 
            +
                        parsedom: string | null;
         | 
| 449 | 
            +
                        marks: import('alex-editor').ObjectType | null;
         | 
| 450 | 
            +
                        styles: import('alex-editor').ObjectType | null;
         | 
| 451 | 
            +
                        textContent: string | null;
         | 
| 452 | 
            +
                        children: any[] | null;
         | 
| 453 | 
            +
                        parent: any | null;
         | 
| 454 | 
            +
                        behavior: "default" | "block";
         | 
| 455 | 
            +
                        namespace: string | null;
         | 
| 456 | 
            +
                        locked: boolean;
         | 
| 457 | 
            +
                        elm: HTMLElement | null;
         | 
| 458 | 
            +
                        isBlock: () => boolean;
         | 
| 459 | 
            +
                        isInblock: () => boolean;
         | 
| 460 | 
            +
                        isInline: () => boolean;
         | 
| 461 | 
            +
                        isClosed: () => boolean;
         | 
| 462 | 
            +
                        isText: () => boolean;
         | 
| 463 | 
            +
                        isBreak: () => boolean;
         | 
| 464 | 
            +
                        isEmpty: () => boolean;
         | 
| 465 | 
            +
                        isSpaceText: () => boolean;
         | 
| 466 | 
            +
                        getUneditableElement: () => AlexElement | null;
         | 
| 467 | 
            +
                        isEqual: (element: AlexElement) => boolean;
         | 
| 468 | 
            +
                        isContains: (element: AlexElement) => boolean;
         | 
| 469 | 
            +
                        isOnlyHasBreak: () => boolean | 0;
         | 
| 470 | 
            +
                        isPreStyle: () => boolean;
         | 
| 471 | 
            +
                        hasMarks: () => boolean;
         | 
| 472 | 
            +
                        hasStyles: () => boolean;
         | 
| 473 | 
            +
                        hasChildren: () => boolean;
         | 
| 474 | 
            +
                        hasContains: (element: AlexElement) => boolean;
         | 
| 475 | 
            +
                        clone: (deep?: boolean | undefined) => AlexElement;
         | 
| 476 | 
            +
                        convertToBlock: () => void;
         | 
| 477 | 
            +
                        toEmpty: () => void;
         | 
| 478 | 
            +
                        getBlock: () => AlexElement;
         | 
| 479 | 
            +
                        getInblock: () => AlexElement | null;
         | 
| 480 | 
            +
                        getInline: () => AlexElement | null;
         | 
| 481 | 
            +
                        isEqualStyles: (element: AlexElement) => boolean;
         | 
| 482 | 
            +
                        isEqualMarks: (element: AlexElement) => boolean;
         | 
| 483 | 
            +
                        isFirst: (element: AlexElement) => boolean;
         | 
| 484 | 
            +
                        isLast: (element: AlexElement) => boolean;
         | 
| 485 | 
            +
                        __render: () => void;
         | 
| 486 | 
            +
                        __fullClone: () => AlexElement;
         | 
| 487 | 
            +
                    }[];
         | 
| 438 488 | 
             
                    __isInputChinese: boolean;
         | 
| 439 489 | 
             
                    __innerSelectionChange: boolean;
         | 
| 440 490 | 
             
                    __chineseInputTimer: any;
         | 
| @@ -475,8 +525,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 475 525 | 
             
                            key: number;
         | 
| 476 526 | 
             
                            type: import('alex-editor').AlexElementType;
         | 
| 477 527 | 
             
                            parsedom: string | null;
         | 
| 478 | 
            -
                            marks: import('alex-editor | 
| 479 | 
            -
                            styles: import('alex-editor | 
| 528 | 
            +
                            marks: import('alex-editor').ObjectType | null;
         | 
| 529 | 
            +
                            styles: import('alex-editor').ObjectType | null;
         | 
| 480 530 | 
             
                            textContent: string | null;
         | 
| 481 531 | 
             
                            children: any[] | null;
         | 
| 482 532 | 
             
                            parent: any | null;
         | 
| @@ -495,7 +545,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 495 545 | 
             
                            getUneditableElement: () => AlexElement | null;
         | 
| 496 546 | 
             
                            isEqual: (element: AlexElement) => boolean;
         | 
| 497 547 | 
             
                            isContains: (element: AlexElement) => boolean;
         | 
| 498 | 
            -
                            isOnlyHasBreak: () => boolean;
         | 
| 548 | 
            +
                            isOnlyHasBreak: () => boolean | 0;
         | 
| 499 549 | 
             
                            isPreStyle: () => boolean;
         | 
| 500 550 | 
             
                            hasMarks: () => boolean;
         | 
| 501 551 | 
             
                            hasStyles: () => boolean;
         | 
| @@ -521,8 +571,8 @@ declare const _default: import('vue').DefineComponent<{ | |
| 521 571 | 
             
                            key: number;
         | 
| 522 572 | 
             
                            type: import('alex-editor').AlexElementType;
         | 
| 523 573 | 
             
                            parsedom: string | null;
         | 
| 524 | 
            -
                            marks: import('alex-editor | 
| 525 | 
            -
                            styles: import('alex-editor | 
| 574 | 
            +
                            marks: import('alex-editor').ObjectType | null;
         | 
| 575 | 
            +
                            styles: import('alex-editor').ObjectType | null;
         | 
| 526 576 | 
             
                            textContent: string | null;
         | 
| 527 577 | 
             
                            children: any[] | null;
         | 
| 528 578 | 
             
                            parent: any | null;
         | 
| @@ -541,7 +591,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 541 591 | 
             
                            getUneditableElement: () => AlexElement | null;
         | 
| 542 592 | 
             
                            isEqual: (element: AlexElement) => boolean;
         | 
| 543 593 | 
             
                            isContains: (element: AlexElement) => boolean;
         | 
| 544 | 
            -
                            isOnlyHasBreak: () => boolean;
         | 
| 594 | 
            +
                            isOnlyHasBreak: () => boolean | 0;
         | 
| 545 595 | 
             
                            isPreStyle: () => boolean;
         | 
| 546 596 | 
             
                            hasMarks: () => boolean;
         | 
| 547 597 | 
             
                            hasStyles: () => boolean;
         | 
| @@ -564,6 +614,7 @@ declare const _default: import('vue').DefineComponent<{ | |
| 564 614 | 
             
                    }[];
         | 
| 565 615 | 
             
                }>;
         | 
| 566 616 | 
             
                textValue: import('vue').ComputedRef<string>;
         | 
| 617 | 
            +
                menuHeight: import('vue').ComputedRef<number | null>;
         | 
| 567 618 | 
             
                collapseToEnd: () => void;
         | 
| 568 619 | 
             
                collapseToStart: () => void;
         | 
| 569 620 | 
             
                undo: () => void;
         | 
| @@ -696,22 +747,31 @@ declare const _default: import('vue').DefineComponent<{ | |
| 696 747 | 
             
                    type: BooleanConstructor;
         | 
| 697 748 | 
             
                    default: boolean;
         | 
| 698 749 | 
             
                };
         | 
| 750 | 
            +
                zIndex: {
         | 
| 751 | 
            +
                    type: NumberConstructor;
         | 
| 752 | 
            +
                    default: number;
         | 
| 753 | 
            +
                };
         | 
| 754 | 
            +
                offset: {
         | 
| 755 | 
            +
                    type: NumberConstructor;
         | 
| 756 | 
            +
                    default: number;
         | 
| 757 | 
            +
                };
         | 
| 699 758 | 
             
            }>> & {
         | 
| 759 | 
            +
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
         | 
| 700 760 | 
             
                onFocus?: ((...args: any[]) => any) | undefined;
         | 
| 701 761 | 
             
                onBlur?: ((...args: any[]) => any) | undefined;
         | 
| 702 762 | 
             
                onChange?: ((...args: any[]) => any) | undefined;
         | 
| 703 763 | 
             
                onKeydown?: ((...args: any[]) => any) | undefined;
         | 
| 704 764 | 
             
                onKeyup?: ((...args: any[]) => any) | undefined;
         | 
| 705 | 
            -
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
         | 
| 706 765 | 
             
                onInsertparagraph?: ((...args: any[]) => any) | undefined;
         | 
| 707 766 | 
             
                onRangeupdate?: ((...args: any[]) => any) | undefined;
         | 
| 708 767 | 
             
                onUpdateview?: ((...args: any[]) => any) | undefined;
         | 
| 709 768 | 
             
            }, {
         | 
| 710 769 | 
             
                color: string | null;
         | 
| 711 770 | 
             
                disabled: boolean;
         | 
| 712 | 
            -
                 | 
| 771 | 
            +
                zIndex: number;
         | 
| 713 772 | 
             
                modelValue: string;
         | 
| 714 773 | 
             
                border: boolean;
         | 
| 774 | 
            +
                menu: MenuConfigType;
         | 
| 715 775 | 
             
                placeholder: string;
         | 
| 716 776 | 
             
                autoheight: boolean;
         | 
| 717 777 | 
             
                toolbar: ToolbarConfigType;
         | 
| @@ -736,5 +796,6 @@ declare const _default: import('vue').DefineComponent<{ | |
| 736 796 | 
             
                tab: boolean;
         | 
| 737 797 | 
             
                plugins: import('../core/tool').PluginType[];
         | 
| 738 798 | 
             
                dark: boolean;
         | 
| 799 | 
            +
                offset: number;
         | 
| 739 800 | 
             
            }, {}>;
         | 
| 740 801 | 
             
            export default _default;
         | 
    
        package/lib/editify/props.d.ts
    CHANGED
    
    | @@ -130,5 +130,13 @@ export declare const EditifyProps: { | |
| 130 130 | 
             
                    type: BooleanConstructor;
         | 
| 131 131 | 
             
                    default: boolean;
         | 
| 132 132 | 
             
                };
         | 
| 133 | 
            +
                zIndex: {
         | 
| 134 | 
            +
                    type: NumberConstructor;
         | 
| 135 | 
            +
                    default: number;
         | 
| 136 | 
            +
                };
         | 
| 137 | 
            +
                offset: {
         | 
| 138 | 
            +
                    type: NumberConstructor;
         | 
| 139 | 
            +
                    default: number;
         | 
| 140 | 
            +
                };
         | 
| 133 141 | 
             
            };
         | 
| 134 142 | 
             
            export type EditifyPropsType = ExtractPublicPropTypes<typeof EditifyProps>;
         |