@hailin-zheng/editor-core 1.0.5 → 1.0.6

package/src/med_editor/framework/element-event-define.ts

@@ -1,142 +0,0 @@
-import { Element, LeafElement, Rect } from "./element-define";
-import { nanoid } from "nanoid";
-import { LeafRenderObject, RenderObject } from "./render-define";
-import { SelectionState } from "./document-selection";
-import { EditorContext } from "./document-context";
-import { TrackRunTypeEnum } from "./impl/text/track-run-impl";
-
-export type EventStage = 'All' | 'Capture' | 'Bubbling';
-export type EventTypes = 'ElementMousedown' | 'ElementMousemove' | 'ElementClick' | 'ElementDblClick' | 'ElementMouseEnter'
-    | 'ElementMouseLeave' | 'BackspaceKey' | 'DeleteKey' | 'ElementShown' | 'ElementContextMenu' | 'GotCursor' | 'LostCursor' | 'ElementKeyDown' | 'ElementDrop' |
-    'ElementTabKey' | 'GetTrackTips';
-
-export type HitRegion = 'header' | 'body' | 'footer' | 'review';
-
-export interface HitEventInfo {
-    relativeRect: Rect,
-    absoluteRect: Rect,
-    offset: number,
-    render: LeafRenderObject,
-    element: LeafElement,
-    shadowRenderIndex: number,
-    hitDocIndex: number,
-    startRegion?: HitRegion
-}
-
-/**
- * 元素事件
- */
-export class ElementEvent {
-    constructor(public ctx: EditorContext) { }
-    /**
-     * 事件源头对象
-     */
-    source!: Element;
-    sourceOffset!: number;
-    sourceRender!: RenderObject;
-    /**
-     * 当前所在的对象
-     */
-    currentElement!: Element;
-    currentRenderObjectX!: number;
-    currentRenderObjectY!: number;
-    //是否取消向上冒泡
-    isCancel!: boolean;
-    globalX!: number;
-    globalY!: number;
-    pageX!: number;
-    pageY!: number;
-    shift!: boolean;
-    ctrl!: boolean;
-    buttons!: number;
-    get selectionState(){
-        return this.ctx.selectionState;
-    }
-}
-
-export interface MenuListener {
-    [listener: string]: <T extends Event>(evt: T) => void;
-}
-export class ContentMenuItem {
-    icon!: string;
-    caption!: string;
-    eventObj!: MenuListener;
-    subItems?: Array<ContentMenuItem> = [];
-}
-/**
- * 鼠标操作的事件
- */
-export class MouseElementEvent extends ElementEvent { }
-
-export class MousedownElementEvent extends ElementEvent { }
-export class KeyboradElementEvent extends ElementEvent {
-    key!: string;
-    sourceEvent!: KeyboardEvent;
-}
-export class GotCursorEvent extends ElementEvent { }
-export class LostCursorEvent extends ElementEvent { }
-export interface ITrackTips {
-    trackRunType: TrackRunTypeEnum;
-    name: string;
-    date: string;
-    content: string;
-}
-export class GetTrackTipsEvent extends ElementEvent {
-    trackTips!: ITrackTips;
-}
-export class ContextMenuElementEvent extends ElementEvent {
-    menus: Array<ContentMenuItem> = [];
-}
-export class DropElementEvent extends ElementEvent {
-    dragElement!: Element;
-}
-
-export interface EventProps<T extends ElementEvent = ElementEvent> { id: string, eventName: string, listener: (evt: T) => void, useCapture: boolean }
-export class EventMap {
-    private map: WeakMap<Element, Array<EventProps<any>>> = new WeakMap();
-
-    add<T extends ElementEvent>(element: Element, eventName: EventTypes, listener: (evt: T) => void, useCapture: boolean): string {
-        const events = this.map.get(element);
-        const eventId = nanoid(8);
-        const eventProps: EventProps<T> = { id: eventId, eventName, listener, useCapture };
-        if (!events) {
-            this.map.set(element, [eventProps]);
-        } else {
-            events.push(eventProps);
-        }
-        return eventId;
-    }
-
-    remove(element: Element, eventId: string): void {
-        const events = this.map.get(element);
-        if (events) {
-            const listenerIndex = events.findIndex(item => item.id === eventId);
-            if (listenerIndex >= 0) {
-                events.splice(listenerIndex, 1);
-            }
-        }
-    }
-
-    removeByType(element: Element, eventName: EventTypes): void {
-        const events = this.map.get(element);
-        if (events) {
-            const filterEvents = events.filter(item => item.eventName === eventName);
-            filterEvents.forEach(item => { this.remove(element, item.id) });
-        }
-    }
-
-    clear(element: Element): void {
-        //const events = this.map.get(element);
-        this.map.delete(element);
-    }
-
-    get(element: Element, eventName: string, useCapture = false): Array<(evt: ElementEvent) => void> {
-        const events = this.map.get(element);
-        if (events) {
-            const listener = events.filter(item => item.eventName === eventName && item.useCapture === useCapture).map(item => item.listener);
-            return listener;
-        }
-        return [];
-
-    }
-}

package/src/med_editor/framework/impl/document/doc-container-impl.ts

@@ -1,24 +0,0 @@
-import { RenderContenxtType } from "@/med_editor/framework/render-context";
-import { BlockContainerRenderObject, RenderObject } from "@/med_editor/framework/render-define";
-import { DocumentRenderObject } from "./doc-impl";
-
-export class DocumentContainerRender extends BlockContainerRenderObject {
-    constructor() {
-        super(null);
-    }
-    beginRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
-        //throw new Error("Method not implemented.");
-    }
-    endRender(ctx: RenderContenxtType, position: { x: number; y: number; }): void {
-        //throw new Error("Method not implemented.");
-    }
-    clone(): RenderObject {
-        throw new Error("Method not implemented.");
-    }
-
-    addPages(pages: Array<DocumentRenderObject>): void {
-        for (let i = 0; i < pages.length; i++) {
-            this.addChild(pages[i]);
-        }
-    }
-}

package/src/med_editor/util/subject.ts

@@ -1,118 +0,0 @@
-import {Element, RefreshType} from "@/med_editor/framework/element-define";
-
-export type EventTypeNamesMap={
-    refresh:RefreshType;
-    click:string;
-}
-
-type eventNameMap=keyof EventTypeNamesMap;
-
-
-export interface EventListenerFn<P extends eventNameMap>{
-    (evt:P):void;
-}
-
-export type IEventListenerMap={
-    [PropName in keyof EventTypeNamesMap]?:Array<(evt:any)=>void>;
-}
-
-export const eventMap: WeakMap<Element, IEventListenerMap> = new WeakMap()
-export interface SubObject{
-    get state():boolean;
-    unsubscribe():void;
-    dispatch(evt:any):void;
-}
-export function addSubscribe<P extends eventNameMap,E>(element: Element, eventName: P, event:(evt:E)=>void): SubObject {
-    let listeners = eventMap.get(element);
-    if (!listeners) {
-        listeners = {};
-        eventMap.set(element, listeners);
-    }
-    let listenersArray = listeners[eventName];
-    if (!listenersArray) {
-        listenersArray = [];
-        listeners[eventName] = listenersArray;
-    }
-    listenersArray.push(event);
-    let flag=true;
-    return {
-        get state() {
-            return flag;
-        },
-        dispatch(evt:E){
-            if(flag){
-                event(evt);
-            }
-        },
-        unsubscribe() {
-            if(flag){
-                flag=false;
-                removeSubscribe(element, eventName, event);
-            }
-        }
-    };
-}
-
-function removeSubscribe<P extends eventNameMap>(element: Element, eventName: P, event:(evt:any)=>void): void {
-    let listeners = eventMap.get(element);
-    if (!listeners) {
-        return;
-    }
-    let listenersArray = listeners[eventName];
-    if (!listenersArray) {
-        return;
-    }
-    const index = listenersArray.indexOf(event);
-    if (index > -1) {
-        listenersArray.splice(index, 1);
-    }
-}
-
-export interface Subscribtion{
-    get state():boolean;
-    unsubscribe():void;
-}
-
-export class EditorSubject<T>{
-    private _value:T;
-    private _listeners:Array<(value:T)=>void>;
-    constructor(value:T){
-        this._value=value;
-        this._listeners=[];
-    }
-    get value(){
-        return this._value;
-    }
-    set value(value:T){
-        this._value=value;
-        this._listeners.forEach(listener=>{
-            listener(value);
-        });
-    }
-    subscribe(listener:(value:T)=>void):Subscribtion{
-        this._listeners.push(listener);
-        let state=true;
-        const unsubscribe=()=>{
-            if(state){
-                state=false;
-                this.unsubscribe(listener);
-            }
-        };
-        return {
-            get state(){
-                return state;
-            },
-            unsubscribe
-        }
-    }
-    unsubscribe(listener:(value:T)=>void){
-        const index=this._listeners.indexOf(listener);
-        if(index>-1){
-            this._listeners.splice(index,1);
-        }
-    }
-
-    dispatch(evt:T){
-        this._listeners.forEach(fn=>fn(evt));
-    }
-}