@easy-editor/core 0.0.1

package/dist/designer/selection.d.ts

@@ -0,0 +1,27 @@
+import type { Node } from '../document';
+import type { Designer } from './designer';
+export declare enum SELECTION_EVENT {
+    CHANGE = "selection:change"
+}
+export declare class Selection {
+    readonly designer: Designer;
+    private emitter;
+    private accessor _selected;
+    get currentDocument(): import("..").Document;
+    constructor(designer: Designer);
+    get selected(): string[];
+    select(id: string): void;
+    selectAll(ids: string[]): void;
+    clear(): void;
+    /**
+     * tidy selected ids(remove invalid ids)
+     */
+    tidy(): void;
+    add(id: string): void;
+    has(id: string): boolean;
+    remove(id: string): void;
+    containsNode(node: Node, excludeRoot?: boolean): boolean;
+    getNodes(): Node[];
+    getTopNodes(includeRoot?: boolean): Node<import("..").NodeSchema>[];
+    onSelectionChange(listener: (ids: string[]) => void): () => void;
+}

package/dist/designer/sensor.d.ts

@@ -0,0 +1,30 @@
+import type { Node } from '../document';
+import type { ComponentInstance } from './component-meta';
+import type { NodeInstance } from './dragon';
+import type { DropLocation, LocateEvent } from './location';
+export interface Sensor<T = Node> {
+    /**
+     * whether the sensor is available
+     */
+    readonly sensorAvailable: boolean;
+    /**
+     * fix location event, add canvasX,canvasY
+     */
+    fixEvent(e: LocateEvent): LocateEvent;
+    /**
+     * locate and activate
+     */
+    locate(e: LocateEvent): DropLocation | undefined | null;
+    /**
+     * whether enter the sensitive area
+     */
+    isEnter(e: LocateEvent): boolean;
+    /**
+     * deactivate
+     */
+    deactiveSensor(): void;
+    /**
+     * get node instance from element
+     */
+    getNodeInstanceFromElement?: (e: Element | null) => NodeInstance<ComponentInstance, T> | null;
+}

package/dist/designer/setting/index.d.ts

@@ -0,0 +1,5 @@
+export * from './setting-entry';
+export * from './setting-field';
+export * from './setting-manager';
+export * from './setting-prop-entry';
+export * from './setting-top-entry';

package/dist/designer/setting/setting-entry.d.ts

@@ -0,0 +1,42 @@
+import type { Editor, Node, SetterManager } from '../..';
+import type { Designer } from '../designer';
+import type { SettingField } from './setting-field';
+export interface SettingEntry {
+    readonly designer: Designer | undefined;
+    readonly id: string;
+    /**
+     * 同样类型的节点
+     */
+    readonly isSameComponent: boolean;
+    /**
+     * 一个
+     */
+    readonly isSingle: boolean;
+    /**
+     * 多个
+     */
+    readonly isMultiple: boolean;
+    /**
+     * 编辑器引用
+     */
+    readonly editor: Editor;
+    readonly setters: SetterManager;
+    /**
+     * 取得子项
+     */
+    get: (propName: string | number) => SettingField | null;
+    readonly nodes: Node[];
+    /**
+     * 获取 node 中的第一项
+     */
+    getNode: () => any;
+}
+export interface SettingTarget {
+    readonly nodes: Node[];
+    readonly props: object;
+    setPropValue(propName: string, value: any): void;
+    getPropValue(propName: string): any;
+    setProps(data: object): void;
+    mergeProps(data: object): void;
+    onPropsChange(fn: () => void): () => void;
+}

package/dist/designer/setting/setting-field.d.ts

@@ -0,0 +1,49 @@
+import type { DynamicSetter, FieldConfig, FieldExtraProps, SetterType } from '../component-meta';
+import type { SettingTopEntry } from './setting-top-entry';
+import { SettingPropEntry } from './setting-prop-entry';
+export interface SetValueOptions {
+    disableMutator?: boolean;
+    type?: PropValueChangedType;
+    fromSetHotValue?: boolean;
+}
+export declare enum PropValueChangedType {
+    /**
+     * normal set value
+     */
+    SET_VALUE = "SET_VALUE",
+    /**
+     * value changed caused by sub-prop value change
+     */
+    SUB_VALUE_CHANGE = "SUB_VALUE_CHANGE"
+}
+export declare class SettingField extends SettingPropEntry {
+    private settingFieldCollector?;
+    readonly isSettingField = true;
+    readonly isRequired: boolean;
+    private _config;
+    private hotValue;
+    parent: SettingTopEntry | SettingField;
+    extraProps: FieldExtraProps;
+    private _title?;
+    get title(): import("../..").PropKey | undefined;
+    private _setter?;
+    private accessor _expanded;
+    private _items;
+    constructor(parent: SettingTopEntry | SettingField, config: FieldConfig, settingFieldCollector?: ((name: string, field: SettingField) => void) | undefined);
+    get setter(): SetterType | null;
+    get expanded(): boolean;
+    setExpanded(value: boolean): void;
+    get items(): SettingField[];
+    get config(): FieldConfig;
+    private initItems;
+    private disposeItems;
+    createField(config: FieldConfig): SettingField;
+    purge(): void;
+    getConfig<K extends keyof FieldConfig>(configName?: K): FieldConfig[K] | FieldConfig;
+    getItems(filter?: (item: SettingField) => boolean): SettingField[];
+    setValue(val: any, isHotValue?: boolean, extraOptions?: SetValueOptions): void;
+    getHotValue(): any;
+    setHotValue(data: any, options?: SetValueOptions): void;
+}
+export declare const isSettingField: (obj: any) => obj is SettingField;
+export declare const isDynamicSetter: (obj: any) => obj is DynamicSetter;

package/dist/designer/setting/setting-manager.d.ts

@@ -0,0 +1,16 @@
+import type { SettingTopEntry } from './setting-top-entry';
+import { type Editor } from '../..';
+export declare class SettingsManager {
+    readonly editor: Editor;
+    private _sessionId;
+    private accessor _settings;
+    get length(): number | undefined;
+    get componentMeta(): import("..").ComponentMeta | null | undefined;
+    get settings(): SettingTopEntry | undefined;
+    private disposeListener;
+    private designer?;
+    constructor(editor: Editor);
+    private init;
+    private setup;
+    purge(): void;
+}

package/dist/designer/setting/setting-prop-entry.d.ts

@@ -0,0 +1,89 @@
+import type { ComponentMeta, Designer, FieldExtraProps, Node, PropKey } from '../..';
+import type { Editor } from '../../editor';
+import type { SetterManager } from '../../setter-manager';
+import type { SettingEntry } from './setting-entry';
+import type { SetValueOptions, SettingField } from './setting-field';
+import type { SettingTopEntry } from './setting-top-entry';
+export declare class SettingPropEntry implements SettingEntry {
+    readonly parent: SettingTopEntry | SettingField;
+    readonly editor: Editor;
+    readonly isSameComponent: boolean;
+    readonly isMultiple: boolean;
+    readonly isSingle: boolean;
+    readonly setters: SetterManager;
+    readonly nodes: Node[];
+    readonly componentMeta: ComponentMeta | null;
+    readonly designer: Designer | undefined;
+    readonly top: SettingTopEntry;
+    readonly isGroup: boolean;
+    readonly type: 'field' | 'group';
+    readonly id: string;
+    readonly emitter: import("../..").EventBus;
+    private accessor _name;
+    get name(): PropKey | undefined;
+    get path(): PropKey[];
+    extraProps: FieldExtraProps;
+    constructor(parent: SettingTopEntry | SettingField, name: PropKey | undefined, type?: 'field' | 'group');
+    getId(): string;
+    setKey(key: PropKey): void;
+    getKey(): PropKey | undefined;
+    remove(): void;
+    /**
+     * 判断当前属性值是否一致
+     * -1 多种值
+     * 0 无值
+     * 1 类似值，比如数组长度一样
+     * 2 单一植
+     */
+    get valueState(): number;
+    /**
+     * 获取当前属性值
+     */
+    getValue(): any;
+    /**
+     * 设置当前属性值
+     */
+    setValue(val: any, isHotValue?: boolean, extraOptions?: SetValueOptions): void;
+    /**
+     * 清除已设置的值
+     */
+    clearValue(): void;
+    /**
+     * 获取子项
+     */
+    get(propName: PropKey): SettingField | null;
+    /**
+     * 设置子级属性值
+     */
+    setPropValue(propName: PropKey, value: any): void;
+    /**
+     * 清除已设置值
+     */
+    clearPropValue(propName: PropKey): void;
+    /**
+     * 获取子级属性值
+     */
+    getPropValue(propName: PropKey): any;
+    /**
+     * 获取顶层附属属性值
+     */
+    getExtraPropValue(propName: string): unknown;
+    /**
+     * 设置顶层附属属性值
+     */
+    setExtraPropValue(propName: string, value: any): void;
+    getNode(): Node<import("../..").NodeSchema>;
+    getName(): string;
+    getProps(): SettingTopEntry;
+    get props(): SettingTopEntry;
+    onValueChange(func: () => any): () => void;
+    notifyValueChange(oldValue: any, newValue: any): void;
+    getDefaultValue(): any;
+    isIgnore(): boolean;
+    getVariableValue(): string;
+    setVariableValue(value: string): void;
+    setUseVariable(flag: boolean): void;
+    isUseVariable(): boolean;
+    get useVariable(): boolean;
+    getMockOrValue(): any;
+}

package/dist/designer/setting/setting-top-entry.d.ts

@@ -0,0 +1,83 @@
+import type { ComponentMeta, Designer, Editor, Node, PropKey, SetterManager } from '../..';
+import type { SettingEntry } from './setting-entry';
+import { SettingField } from './setting-field';
+export declare const generateSessionId: (nodes: Node[]) => string;
+export declare class SettingTopEntry implements SettingEntry {
+    readonly editor: Editor;
+    readonly nodes: Node[];
+    private emitter;
+    private _items;
+    private _componentMeta;
+    private _isSame;
+    private _settingFieldMap;
+    readonly path: never[];
+    readonly top: this;
+    readonly parent: this;
+    get componentMeta(): ComponentMeta | null;
+    get items(): SettingField[];
+    /**
+     * 同样的
+     */
+    get isSameComponent(): boolean;
+    /**
+     * 一个
+     */
+    get isSingle(): boolean;
+    get isLocked(): boolean;
+    /**
+     * 多个
+     */
+    get isMultiple(): boolean;
+    readonly id: string;
+    readonly first: Node;
+    readonly designer: Designer | undefined;
+    readonly setters: SetterManager;
+    disposeFunctions: any[];
+    constructor(editor: Editor, nodes: Node[]);
+    private setupComponentMeta;
+    private setupItems;
+    private setupEvents;
+    /**
+     * 获取当前属性值
+     */
+    getValue(): import("../..").PropsMap | null;
+    /**
+     * 设置当前属性值
+     */
+    setValue(val: any): void;
+    /**
+     * 获取子项
+     */
+    get(propName: PropKey): SettingField | null;
+    /**
+     * 设置子级属性值
+     */
+    setPropValue(propName: PropKey, value: any): void;
+    /**
+     * 清除已设置值
+     */
+    clearPropValue(propName: PropKey): void;
+    /**
+     * 获取子级属性值
+     */
+    getPropValue(propName: PropKey): any;
+    /**
+     * 获取顶层附属属性值
+     */
+    getExtraPropValue(propName: string): unknown;
+    /**
+     * 设置顶层附属属性值
+     */
+    setExtraPropValue(propName: string, value: any): void;
+    setProps(data: object): void;
+    mergeProps(data: object): void;
+    private disposeItems;
+    purge(): void;
+    getProp(propName: PropKey): SettingField | null;
+    getNode(): Node<import("../..").NodeSchema>;
+}
+interface Purgeable {
+    purge(): void;
+}
+export declare const isPurgeable: (obj: any) => obj is Purgeable;
+export {};

package/dist/document/document.d.ts

@@ -0,0 +1,89 @@
+import type { ComponentsMap, Designer, DropLocation } from '../designer';
+import type { Project } from '../project';
+import type { Simulator } from '../simulator';
+import type { NodeSchema, RootSchema } from '../types';
+import { TRANSFORM_STAGE } from '../types';
+import { History } from './history';
+import { Node } from './node/node';
+export declare enum DOCUMENT_EVENT {
+    ADD = "document:add",
+    REMOVE = "document:remove",
+    OPEN_CHANGE = "document:open.change",
+    OPEN = "document:open"
+}
+export declare class Document {
+    readonly isDocument = true;
+    private emitter;
+    id: string;
+    /** document is open or not */
+    accessor _opened: boolean;
+    /** document is blank or not */
+    private _blank;
+    /** document root node */
+    rootNode: Node | null;
+    get root(): Node<NodeSchema> | null;
+    getRoot(): Node<NodeSchema> | null;
+    private _nodesMap;
+    get nodesMap(): Map<string, Node<NodeSchema>>;
+    get simulator(): Simulator | null;
+    /** 对应 document 的 path */
+    get fileName(): string;
+    set fileName(fileName: string);
+    private accessor nodes;
+    get opened(): boolean;
+    isBlank(): boolean;
+    readonly history: History;
+    getHistory(): History<RootSchema>;
+    readonly project: Project;
+    readonly designer: Designer;
+    private accessor _dropLocation;
+    set dropLocation(loc: DropLocation | null);
+    get dropLocation(): DropLocation | null;
+    get schema(): RootSchema;
+    constructor(project: Project, schema?: RootSchema);
+    import(schema?: RootSchema, checkId?: boolean): void;
+    export(stage?: TRANSFORM_STAGE): RootSchema;
+    remove(): void;
+    purge(): void;
+    createNode(schema: NodeSchema, checkId?: boolean): Node<NodeSchema>;
+    getNode(id: string): Node<NodeSchema> | null;
+    getNodeCount(): number;
+    hasNode(id: string): boolean;
+    removeNode(idOrNode: string | Node): void;
+    private internalRemoveNode;
+    unlinkNode(node: Node): void;
+    migrateNode(node: Node, newParent: Node): void;
+    batchRemoveNode(idOrNodeList: (string | Node)[]): void;
+    insertNode(parent: Node, thing: Node | NodeSchema, at?: number, copy?: boolean): Node<NodeSchema> | null;
+    /**
+     * insert multiple nodes
+     */
+    insertNodes(parent: Node, nodes: Node[] | NodeSchema[], at?: number, copy?: boolean): Node<NodeSchema>[];
+    open(): this;
+    close(): void;
+    /**
+     * use open a document and suspense other documents
+     */
+    private setOpened;
+    suspense(): void;
+    activate(): void;
+    /**
+     * check if there is unsaved change for document
+     */
+    isModified(): boolean;
+    /**
+     * get components map of all the nodes in this document
+     * @param extraComps - extra components that will be added to the components map, use for custom components
+     */
+    getComponentsMap(extraComps?: string[]): ComponentsMap;
+    getComponent(componentName: string): any;
+    getComponentMeta(componentName: string): import("..").ComponentMeta;
+    toData(extraComps?: string[]): {
+        componentsMap: ComponentsMap;
+        componentsTree: RootSchema[];
+    };
+    onReady(listener: () => void): () => void;
+    onNodeAdd(listener: (node: Node) => void): () => void;
+    onNodeRemove(listener: (id: string) => void): () => void;
+}
+export declare function isDocument(obj: any): obj is Document;

package/dist/document/history.d.ts

@@ -0,0 +1,76 @@
+import type { RootSchema } from '../types';
+import type { Document } from './document';
+export interface Serialization<K = RootSchema, T = string> {
+    serialize(data: K): T;
+    unserialize(data: T): K;
+}
+export declare enum HISTORY_EVENT {
+    STATE_CHANGE = "history:state.change",
+    CURSOR_CHANGE = "history:cursor.change"
+}
+export declare class History<T = RootSchema> {
+    private redoer;
+    readonly document?: Document | undefined;
+    emitter: import("..").EventBus;
+    /** current record */
+    private session;
+    /** all records */
+    private records;
+    /** as a cursor of records to go back and forward */
+    private point;
+    private asleep;
+    /** current recorded data */
+    get hotData(): string;
+    private timeGap;
+    private serialization;
+    setSerialization(serialization: Serialization<T, string>): void;
+    constructor(dataFn: () => T | null, redoer: (data: T) => void, document?: Document | undefined);
+    /**
+     * check if there is unsaved change for history
+     */
+    isSavePoint(): boolean;
+    private sleep;
+    private wakeup;
+    go(originalCursor: number): void;
+    back(): void;
+    forward(): void;
+    savePoint(): void;
+    destroy(): void;
+    /**
+     *  |    1     |     1    |    1     |
+     *  | -------- | -------- | -------- |
+     *  | modified | redoable | undoable |
+     * eg.
+     *  7 means : modified && redoable && undoable
+     *  5 means : modified && undoable
+     *  ...
+     */
+    getState(): number;
+    isModified(): boolean;
+    isRedoable(): boolean;
+    isUndoable(): boolean;
+    onStateChange(listener: () => void): () => void;
+    onCursorChange(func: () => void): () => void;
+}
+/**
+ * Session is a record of History
+ */
+export declare class Session<T = string> {
+    readonly cursor: number;
+    private timeGap;
+    private _data;
+    private activeTimer;
+    get data(): T;
+    constructor(cursor: number, data: T, timeGap?: number);
+    /**
+     * log data
+     *  log may be executed multiple times, and it has a timeGap period, during this period,
+     *  the changes will only be recorded in this Session, until the timeGap period will be reset
+     *  you can see it in the reaction function of History
+     */
+    log(data: T): void;
+    isActive(): boolean;
+    end(): void;
+    private setTimer;
+    private clearTimer;
+}

package/dist/document/index.d.ts

@@ -0,0 +1,6 @@
+export * from './document';
+export * from './history';
+export * from './node/node';
+export * from './node/node-children';
+export * from './prop/prop';
+export * from './prop/props';

package/dist/document/node/node-children.d.ts

@@ -0,0 +1,51 @@
+import type { NodeSchema } from '../../types';
+import type { Node } from './node';
+import { TRANSFORM_STAGE } from '../../types';
+export declare enum NODE_CHILDREN_EVENT {
+    CHANGE = "nodeChildren:change",
+    INSERT = "nodeChildren:insert"
+}
+export declare class NodeChildren {
+    private emitter;
+    readonly owner: Node;
+    getNode(): Node<NodeSchema>;
+    accessor children: Node[];
+    get size(): number;
+    get isEmptyNode(): boolean;
+    isEmpty(): boolean;
+    constructor(owner: Node, data?: NodeSchema[]);
+    export(stage?: TRANSFORM_STAGE): NodeSchema[];
+    import(data?: NodeSchema | NodeSchema[], checkId?: boolean): void;
+    remove(purge?: boolean, useMutator?: boolean): void;
+    private purged;
+    purge(): void;
+    internalInitParent(): void;
+    internalUnlinkChild(node: Node): boolean;
+    unlinkChild(node: Node): void;
+    delete(node: Node): boolean;
+    internalDelete(node: Node, purge?: boolean, useMutator?: boolean): boolean;
+    get(index: number): Node<NodeSchema> | null;
+    has(node: Node): boolean;
+    insert(node: Node, at?: number | null): void;
+    /**
+     * insert a node into the children
+     * @param node
+     * @param at if at is null or -1, insert the node to the end of the children
+     */
+    internalInsert(node: Node, at?: number | null, useMutator?: boolean): void;
+    mergeChildren(remover: (node: Node, idx: number) => boolean, adder: (children: Node[]) => NodeSchema[] | null, sorter: (firstNode: Node, secondNode: Node) => number): any;
+    indexOf(node: Node): number;
+    find(f: (value: Node, index: number, obj: Node[]) => unknown): Node<NodeSchema> | undefined;
+    forEach(fn: (node: Node, index: number) => void): void;
+    reverse(): Node[];
+    map(fn: (node: Node, index: number) => Node): Node[];
+    every(fn: (node: Node, index: number) => boolean): boolean;
+    some(fn: (node: Node, index: number) => boolean): boolean;
+    filter(fn: (node: Node, index: number) => boolean): Node[];
+    reduce(fn: (acc: any, cur: Node) => any, initialValue: any): any;
+    onChange(listener: (info?: {
+        type: string;
+        node: Node;
+    }) => void): () => void;
+    onInsert(listener: (node: Node) => void): () => void;
+}