@hailin-zheng/editor-core 1.0.7 → 1.0.10

package/{lib/framework/impl/text/text-impl.js → src/med_editor/framework/impl/text/text-impl.ts}

@@ -1,13 +1,16 @@
-import { SelectionRange } from "@/med_editor/framework/document-selection";
-import { TextProps } from "@/med_editor/framework/element-props";
-import { ElementUtil } from "@/med_editor/framework/element-util";
-import { LeafRenderObject } from "@/med_editor/framework/render-define";
-import { LeafElement, ElementFactory, ModifyFlag } from "../../element-define";
+import { SelectionRange } from "../../document-selection";
+import { ContextMenuElementEvent } from "../../element-event-define";
+import { TextProps } from "../../element-props";
+import { ElementUtil } from "../../element-util";
+import { LeafRenderObject, RenderObject } from "../../render-define";
+import { LeafElement, ElementFactory, Element, SerializeProps, ViewOptions, ModifyFlag } from "../../element-define";
 import { watchChanged } from "../../notify";
-export class TextGroupElement extends LeafElement {
+import { RenderContenxtType, TextUnits } from "../../render-context";
+
+export class TextGroupElement extends LeafElement<TextProps> {
     //props: TextProps;
-    textMeasures = [];
-    isMeasure = false;
+    textMeasures: Array<TextUnits> = [];
+    isMeasure: boolean = false;
     constructor() {
         super('text');
         this.props = new TextProps();
@@ -17,7 +20,7 @@ export class TextGroupElement extends LeafElement {
         });
         //this.addPropValueChangedSub(this.props);
         //this.addsubscribe(this, this.props.onPropertyChangedSubject.subscribe(() => { this.clearTextCache() }));
-        this.addEvent('ElementContextMenu', (evt) => {
+        this.addEvent<ContextMenuElementEvent>('ElementContextMenu', (evt) => {
             const ss = evt.selectionState;
             evt.menus.push({
                 icon: "EditStyle", caption: "选中样式组合", eventObj: {
@@ -28,28 +31,30 @@ export class TextGroupElement extends LeafElement {
                         ss.addRange(range);
                     }
                 }
-            });
+            })
         });
     }
-    set text(val) {
+    set text(val: string) {
         this.splice(0, this.textMeasures.length, val);
     }
-    splice(index, deleteCount, addText = null) {
+
+    splice(index: number, deleteCount: number, addText: string | null = null): void {
         this.isMeasure = false;
         addText = addText ?? '';
         const addTextUnits = addText.split('').map(char => ({ sourceSize: 0, actualSize: 0, char }));
         if (this.textMeasures.length === 0) {
             this.textMeasures = addTextUnits;
-        }
-        else {
+        } else {
             this.textMeasures.splice(index, deleteCount, ...addTextUnits);
         }
         this.pubOnChange('self');
     }
+
     get text() {
         return this.textMeasures.map(item => item.char).join('');
     }
-    createRenderObject(options, renderCtx) {
+
+    createRenderObject(options: ViewOptions, renderCtx: RenderContenxtType): RenderObject {
         if (!this.isMeasure || this.modifyFlag !== ModifyFlag.None) {
             renderCtx.contentContext.measureTextUnits(this.textMeasures, this.props);
             this.isMeasure = true;
@@ -60,7 +65,8 @@ export class TextGroupElement extends LeafElement {
         render.measure();
         return render;
     }
-    serialize(viewOptions) {
+
+    serialize(viewOptions: ViewOptions): SerializeProps & any {
         //修饰元素不序列化
         if (this.isDecorate) {
             return null;
@@ -72,18 +78,21 @@ export class TextGroupElement extends LeafElement {
             },
             content: this.text,
             complete: true
-        };
+        }
     }
-    clone(data) {
+
+    clone(data: boolean): TextGroupElement {
         const clone = new TextGroupElement();
         this.props.clone(clone.props);
         clone.text = this.text;
         return clone;
     }
-    destroy() {
+
+    destroy(): void {
         super.destroy();
     }
-    spliceText(startOffset, endOffset, xCopy) {
+
+    spliceText(startOffset: number, endOffset: number, xCopy: boolean): TextGroupElement | null {
         endOffset = endOffset === -1 ? this.textMeasures.length : endOffset;
         if (endOffset === startOffset) {
             return null;
@@ -92,20 +101,22 @@ export class TextGroupElement extends LeafElement {
         this.props.clone(clone.props);
         if (xCopy) {
             clone.textMeasures = this.textMeasures.splice(startOffset, endOffset - startOffset);
-        }
-        else {
+        } else {
             clone.textMeasures = this.textMeasures.filter((item, index) => index >= startOffset && index < endOffset);
         }
         clone.textMeasures = clone.textMeasures.map(item => ({ sourceSize: 0, actualSize: 0, char: item.char }));
         return clone;
     }
-    clearTextCache() {
+
+    clearTextCache(): void {
         this.isMeasure = false;
     }
 }
-export class TextGroupRenderObject extends LeafRenderObject {
-    textMeasures;
-    render(ctx, position) {
+
+
+export class TextGroupRenderObject extends LeafRenderObject<TextGroupElement> {
+    textMeasures!: Array<TextUnits>;
+    render(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
         //null-text不打印
         if (ctx.drawMode === 'print' && this.element.isDecorate) {
             return;
@@ -117,33 +128,36 @@ export class TextGroupRenderObject extends LeafRenderObject {
         // if (this.element.isMouseenter) {
         //     ctx.overlaysContext.strokeRect(position.x, position.y, this.rect.width, this.rect.height, CommonUtil.randomColor());
         // }
+
     }
-    constructor(element) {
+    constructor(element: TextGroupElement) {
         super(element);
     }
-    clone() {
+    clone(): RenderObject {
         const cloneRender = new TextGroupRenderObject(this.element);
         cloneRender.disableClick = this.disableClick;
         cloneRender.rect = ElementUtil.cloneRect(this.rect);
         cloneRender.textMeasures = [...this.textMeasures];
         return cloneRender;
     }
-    measure() {
+
+    measure(): void {
         this.rect.width = this.textMeasures.reduce((prev, curr) => prev + curr.actualSize, 0);
         this.rect.height = this.element.props.fontSize;
     }
 }
-export class TextGroupFactory extends ElementFactory {
-    match(type) {
+
+export class TextGroupFactory extends ElementFactory<null> {
+    match(type: string): boolean {
         return type === 'text';
     }
-    createElement(data, renderCtx) {
-        const props = data.props;
-        const text = data.content;
+    createElement(data: any, renderCtx: RenderContenxtType): Element {
+        const props = data.props as TextProps;
+        const text = data.content as string;
         const textGroup = new TextGroupElement();
         textGroup.text = text;
         ElementUtil.readTextProps(textGroup.props, props, this.options);
         return textGroup;
     }
+
 }
-//# sourceMappingURL=text-impl.js.map

package/{lib/framework/impl/text/track-run-impl.js → src/med_editor/framework/impl/text/track-run-impl.ts}

@@ -1,31 +1,42 @@
-import { InlineGroupElement, ElementFactory } from "@/med_editor/framework/element-define";
-import { InlineGroupRenderObject } from "@/med_editor/framework/render-define";
-import { TrackRunProps } from "@/med_editor/framework/element-props";
-import { ElementUtil } from "@/med_editor/framework/element-util";
+import {
+    InlineGroupElement,
+    Position,
+    SerializeProps,
+    ViewOptions,
+    Element,
+    ElementFactory, readElementProps
+} from "../../element-define";
+import { RenderContenxtType } from "../../render-context";
+import { InlineGroupRenderObject, RenderObject } from "../../render-define";
+import { TrackRunProps } from "../../element-props";
+import { ElementUtil } from "../../element-util";
 import { ElementSerialize } from "../../element-serialize";
+import { GetTrackTipsEvent } from "../../element-event-define";
 import { nanoid } from "nanoid";
-export var TrackRunTypeEnum;
-(function (TrackRunTypeEnum) {
-    TrackRunTypeEnum["Inserted"] = "ins-run";
-    TrackRunTypeEnum["Deleted"] = "del-run";
-})(TrackRunTypeEnum || (TrackRunTypeEnum = {}));
-export class TrackRunElement extends InlineGroupElement {
-    constructor(trackType) {
+export enum TrackRunTypeEnum {
+    Inserted = 'ins-run',
+    Deleted = 'del-run',
+}
+type NullableType<T> = T | null;
+export class TrackRunElement extends InlineGroupElement<TrackRunProps> {
+    constructor(trackType: TrackRunTypeEnum) {
         super(trackType);
         this.props = new TrackRunProps(trackType);
-        this.addEvent('GetTrackTips', (evt) => {
+        this.addEvent<GetTrackTipsEvent>('GetTrackTips', (evt) => {
             evt.trackTips = {
-                trackRunType: this.type,
+                trackRunType: this.type as TrackRunTypeEnum,
                 name: this.props.userName,
                 date: this.props.date,
                 content: ElementSerialize.serializeString(this, { all: true })
             };
             console.log(evt.trackTips.content);
+
             evt.isCancel = true;
         });
     }
-    clone(data) {
-        const clone = new TrackRunElement(this.type);
+
+    clone(data: boolean): Element {
+        const clone = new TrackRunElement(this.type as TrackRunTypeEnum);
         this.props.clone(clone.props);
         if (data) {
             const length = this.length;
@@ -35,25 +46,28 @@ export class TrackRunElement extends InlineGroupElement {
         }
         return clone;
     }
-    createRenderObject(options, renderCtx) {
+
+    createRenderObject(options: ViewOptions, renderCtx: RenderContenxtType): NullableType<RenderObject> {
         if (!options.showTrackChanges && this.type === TrackRunTypeEnum.Deleted) {
             return null;
         }
         return new TrackRunRenderObject(this);
     }
-    serialize(viewOptions) {
+
+    serialize(viewOptions: ViewOptions): SerializeProps | null {
         return {
             type: this.type,
             props: this.props.getSerializeProps()
         };
     }
-    split(index) {
+
+    split(index: number): TrackRunElement | null {
         if (index === 0 || index === this.length) {
             return null;
         }
-        const clone = new TrackRunElement(this.type);
+        const clone = new TrackRunElement(this.type as TrackRunTypeEnum);
         this.props.clone(clone.props);
-        const items = [];
+        const items: Array<Element> = [];
         for (let i = index; i < this.length; i++) {
             const child = this.getChild(i);
             items.push(child);
@@ -65,15 +79,18 @@ export class TrackRunElement extends InlineGroupElement {
         return clone;
     }
 }
-export class TrackRunRenderObject extends InlineGroupRenderObject {
-    constructor(ele) {
+
+export class TrackRunRenderObject extends InlineGroupRenderObject<TrackRunElement> {
+    constructor(ele: TrackRunElement) {
         super(ele);
     }
-    beginRender(ctx, position) {
+
+    beginRender(ctx: RenderContenxtType, position: Position): void {
         const color = this.element.type === 'ins-run' ? 'green' : 'red';
         //ctx.overlaysContext.strokeRect(position.x, position.y, this.rect.width, this.rect.height, color);
     }
-    clone() {
+
+    clone(): RenderObject {
         const cloneRender = new TrackRunRenderObject(this.element);
         cloneRender.rect = ElementUtil.cloneRect(this.rect);
         for (let i = 0; i < this.length; i++) {
@@ -81,7 +98,8 @@ export class TrackRunRenderObject extends InlineGroupRenderObject {
         }
         return cloneRender;
     }
-    endRender(ctx, position) {
+
+    endRender(ctx: RenderContenxtType, position: Position): void {
         const { x, y } = position;
         const color = this.element.type === 'ins-run' ? 'green' : 'red';
         for (let i = 0; i < this.length; i++) {
@@ -96,17 +114,22 @@ export class TrackRunRenderObject extends InlineGroupRenderObject {
         }
     }
 }
-export class RunElementFactory extends ElementFactory {
-    createElement(data, renderCtx) {
-        const ele = new TrackRunElement(data.type);
+
+export class RunElementFactory extends ElementFactory<TrackRunProps>{
+
+    createElement(data: readElementProps<TrackRunProps>, renderCtx: RenderContenxtType): TrackRunElement {
+        const ele = new TrackRunElement(data.type as TrackRunTypeEnum);
         ele.props.userId = data.props?.userId ?? '';
         ele.props.userName = data.props?.userName ?? '';
         ele.props.date = data.props?.date ?? '';
         ele.props.id = data.props?.id ?? nanoid(5);
         return ele;
     }
-    match(type) {
+
+    match(type: string): boolean {
         return type === TrackRunTypeEnum.Inserted || type === TrackRunTypeEnum.Deleted;
     }
+
+
 }
-//# sourceMappingURL=track-run-impl.js.map
+

package/{lib/framework/notify.js → src/med_editor/framework/notify.ts}

@@ -1,24 +1,31 @@
 const EDITOR_REACTIVE = '__editor_reactive';
-const ITERATOR_KEY = Symbol('iterator-key');
-export const reactiveMap = new WeakMap();
-export const targetMaps = new WeakMap();
-const activeFns = [];
-function track(target, p) {
+const ITERATOR_KEY = Symbol('iterator-key')
+export const reactiveMap = new WeakMap<object, object>();
+export const targetMaps = new WeakMap<object, Map<propType, Set<notifyCallback>>>();
+type propType = string | number | symbol;
+interface notifyCallback {
+    (target: object, p: propType, oldValue: any, newValue: any): string | undefined | void;
+}
+
+
+const activeFns: Array<notifyCallback> = [];
+function track(target: object, p: propType) {
     const activeFn = activeFns[activeFns.length - 1];
     if (!activeFn) {
         return;
     }
-    let targetMap = targetMaps.get(target);
+    let targetMap = targetMaps.get(target)
     if (!targetMap) {
-        targetMaps.set(target, (targetMap = new Map()));
+        targetMaps.set(target, (targetMap = new Map()))
     }
     let effectFns = targetMap.get(p);
     if (!effectFns) {
-        targetMap.set(p, (effectFns = new Set()));
+        targetMap.set(p, (effectFns = new Set()))
     }
-    effectFns.add(activeFn);
+    effectFns.add(activeFn)
 }
-function trigger(target, p, oldValue, newValue) {
+
+function trigger(target: object, p: propType, oldValue: any, newValue: any): void {
     //不需要触发
     if (p.toString().startsWith('__')) {
         return;
@@ -29,21 +36,22 @@ function trigger(target, p, oldValue, newValue) {
     }
     const effectFns = targetMap.get(p);
     const iteratorFns = targetMap.get(ITERATOR_KEY);
-    const fns = new Set();
+    const fns = new Set<notifyCallback>();
     effectFns && effectFns.forEach(item => fns.add(item));
     iteratorFns && iteratorFns.forEach(item => fns.add(item));
     const activeFn = activeFns[activeFns.length - 1];
     //防止死循环，过滤正在运行的副作用
     if (activeFn) {
-        fns.delete(activeFn);
+        fns.delete(activeFn)
     }
     fns.forEach(fn => {
-        fn(target, p, oldValue, newValue);
+        fn(target, p, oldValue, newValue)
     });
 }
-export function watchChanged(source, cb) {
-    if (source[EDITOR_REACTIVE]) {
-        addToTrack(source['raw'], source, cb);
+
+export function watchChanged<T extends object>(source: T, cb: notifyCallback): T {
+    if ((<any>source)[EDITOR_REACTIVE]) {
+        addToTrack((<any>source)['raw'], source, cb);
         return source;
     }
     if (isDate(source)) {
@@ -51,7 +59,7 @@ export function watchChanged(source, cb) {
     }
     const existProxy = reactiveMap.get(source);
     if (existProxy) {
-        return existProxy;
+        return existProxy as T;
     }
     const proxy = new Proxy(source, {
         get(target, p, receiver) {
@@ -61,7 +69,7 @@ export function watchChanged(source, cb) {
             if (p === EDITOR_REACTIVE) {
                 return true;
             }
-            const res = Reflect.get(target, p, receiver);
+            const res = Reflect.get(target, p, receiver)
             if (typeof res === 'object' && res) {
                 return watchChanged(res, cb);
             }
@@ -69,9 +77,9 @@ export function watchChanged(source, cb) {
         },
         set(target, p, newValue, receiver) {
             //console.log('设置' + p.toString())
-            const oldValue = target[p];
+            const oldValue = (<any>target)[p];
             const res = Reflect.set(target, p, newValue, receiver);
-            if (receiver.raw === target) {
+            if ((<any>receiver).raw === target) {
                 if (oldValue !== newValue && (oldValue === oldValue || newValue === newValue)) {
                     trigger(target, p, oldValue, newValue);
                 }
@@ -84,33 +92,39 @@ export function watchChanged(source, cb) {
             return res;
         },
         defineProperty(target, p, attributes) {
-            const res = Reflect.defineProperty(target, p, attributes);
+            const res = Reflect.defineProperty(target, p, attributes)
             trigger(target, p, null, null);
             return res;
         }
-    });
+    })
     addToTrack(source, proxy, cb);
     return proxy;
 }
-function addToTrack(source, proxy, cb) {
+
+function addToTrack(source: object, proxy: object, cb: notifyCallback): void {
     activeFns.push(cb);
     track(source, ITERATOR_KEY);
     activeFns.pop();
     reactiveMap.set(source, proxy);
 }
-export function setNotifyChangedCallback(target, p, cb) {
-    let trackTarget = target;
-    if (target[EDITOR_REACTIVE]) {
-        trackTarget = target['raw'];
+
+
+export function setNotifyChangedCallback(target: object, p: propType, cb: notifyCallback): void {
+    let trackTarget: any = target;
+    if ((<any>target)[EDITOR_REACTIVE]) {
+        trackTarget = (<any>target)['raw'];
     }
-    activeFns.push(cb);
+    activeFns.push(cb)
     track(trackTarget, p);
-    activeFns.pop();
+    activeFns.pop()
+}
+
+export const isDate = (val: unknown): val is Date => val instanceof Date
+
+export const objectToString = Object.prototype.toString
+export const toTypeString = (value: unknown): string =>
+    objectToString.call(value)
+
+export const toRawType = (value: unknown): string => {
+    return toTypeString(value).slice(8, -1)
 }
-export const isDate = (val) => val instanceof Date;
-export const objectToString = Object.prototype.toString;
-export const toTypeString = (value) => objectToString.call(value);
-export const toRawType = (value) => {
-    return toTypeString(value).slice(8, -1);
-};
-//# sourceMappingURL=notify.js.map