@easy-editor/core 0.0.1

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

@@ -0,0 +1,233 @@
+import type { NodeSchema } from '../../types';
+import type { Document } from '../document';
+import type { PropValue, PropsMap } from '../prop/prop';
+import { type SettingTopEntry } from '../..';
+import { TRANSFORM_STAGE } from '../../types';
+import { Props } from '../prop/props';
+import { NodeChildren } from './node-children';
+export declare enum NODE_EVENT {
+    ADD = "node:add",
+    REMOVE = "node:remove",
+    VISIBLE_CHANGE = "node:visible.change",
+    LOCK_CHANGE = "node:lock.change",
+    PROP_CHANGE = "node:prop.change"
+}
+export declare class Node<Schema extends NodeSchema = NodeSchema> {
+    readonly document: Document;
+    protected emitter: import("../..").EventBus;
+    readonly isNode = true;
+    readonly id: string;
+    readonly componentName: string;
+    protected _children: NodeChildren | null;
+    private accessor _parent;
+    get parent(): Node<NodeSchema> | null;
+    get children(): NodeChildren | null;
+    get childrenNodes(): Node<NodeSchema>[];
+    /**
+     * if the node is the root node or not linked, return -1
+     */
+    get index(): number;
+    /**
+     * z-index level of this node
+     */
+    get zLevel(): number;
+    get title(): string;
+    get icon(): string | undefined;
+    private purged;
+    /**
+     * 是否已销毁
+     */
+    get isPurged(): boolean;
+    props: Props;
+    _settingEntry: SettingTopEntry;
+    get settingEntry(): SettingTopEntry;
+    constructor(document: Document, Schema: Schema);
+    import(data: Schema, checkId?: boolean): void;
+    export<T = NodeSchema>(stage?: TRANSFORM_STAGE): T;
+    purge(): void;
+    toData(): NodeSchema;
+    /**
+     * get node schema
+     */
+    get schema(): Schema;
+    set schema(data: Schema);
+    initBuiltinProps(): void;
+    private initProps;
+    private upgradeProps;
+    /**
+     * relate to componentMeta.advanced.initialChildren
+     */
+    private initialChildren;
+    /**
+     * link to componentMeta.advanced.callbacks.onNodeAdd
+     */
+    didDropIn(dragNode: Node): void;
+    /**
+     * link to componentMeta.advanced.callbacks.onNodeRemove
+     */
+    didDropOut(dragNode: Node): void;
+    /**
+     * link to componentMeta.advanced.callbacks.onSelectHook
+     */
+    canSelect(): boolean;
+    /**
+     * link to componentMeta.advanced.callbacks.onClickHook
+     */
+    canClick(e: MouseEvent): any;
+    select(): void;
+    hover(flag?: boolean): void;
+    getChildren(): NodeChildren | null;
+    getComponentName(): string;
+    getParent(): Node<NodeSchema> | null;
+    getId(): string;
+    getIndex(): number;
+    getNode(): this;
+    getRoot(): Node<NodeSchema> | null;
+    getProps(): Props;
+    get isContainer(): boolean;
+    get isRoot(): boolean;
+    /**
+     * whether child nodes are included
+     */
+    get isParental(): boolean;
+    /**
+     * whether this node is a leaf node
+     */
+    get isLeaf(): boolean;
+    toString(): string;
+    hide(flag?: boolean): void;
+    get hidden(): boolean;
+    get isHidden(): boolean;
+    lock(flag?: boolean): void;
+    get locked(): boolean;
+    get isLocked(): boolean;
+    hasCondition(): boolean;
+    /**
+     * has loop when 1. loop is validArray with length > 1 ; OR  2. loop is variable object
+     * @return boolean, has loop config or not
+     */
+    hasLoop(): boolean;
+    getProp(path: string, createIfNone?: boolean): import("..").Prop | null;
+    getExtraProp(key: string, createIfNone?: boolean): import("..").Prop | null;
+    setExtraProp(key: string, value: PropValue): void;
+    getPropValue(path: string): unknown;
+    setPropValue(path: string, value: PropValue): void;
+    getExtraPropValue(key: string): unknown;
+    setExtraPropValue(key: string, value: PropValue): void;
+    clearPropValue(path: string): void;
+    mergeProps(props: PropsMap): void;
+    setProps(props?: PropsMap | Props | null): void;
+    internalSetParent(parent: Node | null, useMutator?: boolean): void;
+    internalUnlinkParent(): void;
+    /**
+     * unlink this node from its parent and document
+     */
+    unlink(): void;
+    /**
+     * migrate this node to a new parent
+     */
+    migrate(newParent: Node): void;
+    /**
+     * if the node is linked in the document tree
+     */
+    get isLinked(): boolean;
+    /**
+     * insert a node at a specific position or a reference node
+     */
+    insert(node: Node, ref?: Node | number, useMutator?: boolean): void;
+    /**
+     * insert a node before a reference node(in current node's children)
+     */
+    insertBefore(node: Node, ref?: Node, useMutator?: boolean): void;
+    /**
+     * insert a node after a reference node(in current node's children)
+     */
+    insertAfter(node: Node, ref?: Node, useMutator?: boolean): void;
+    remove(purge?: boolean, useMutator?: boolean): void;
+    removeChild(node: Node): void;
+    isValidComponent(): boolean;
+    get componentMeta(): import("../..").ComponentMeta;
+    get propsData(): PropsMap | null;
+    getRect(): DOMRect | null;
+    getDOMNode(): any;
+    /**
+     * use schema to update this node
+     */
+    wrapWith(schema: Schema): Node<NodeSchema> | null | undefined;
+    /**
+     * replace this node with a new node
+     */
+    replaceWith(schema: Schema, migrate?: boolean): Node<NodeSchema> | null | undefined;
+    /**
+     * replace a child node with a new node
+     */
+    replaceChild(node: Node, data: Schema): Node | null;
+    /**
+     * check if this node contains another node
+     */
+    contains(node: Node): boolean;
+    /**
+     * get the parent node at a specific depth
+     */
+    getZLevelTop(zLevel: number): Node<NodeSchema> | null;
+    /**
+     * compare the position of this node and another node
+     *
+     *  - 16 thisNode contains otherNode
+     *  - 8  thisNode contained_by otherNode
+     *  - 2  thisNode before or after otherNode
+     *  - 0  thisNode same as otherNode
+     */
+    comparePosition(otherNode: Node): PositionNO;
+    /**
+     * get next sibling node
+     */
+    get nextSibling(): Node | null | undefined;
+    /**
+     * get previous sibling node
+     */
+    get prevSibling(): Node | null | undefined;
+    mergeChildren(remover: (node: Node, idx: number) => any, adder: (children: Node[]) => Schema[] | null, sorter: (firstNode: Node, secondNode: Node) => any): void;
+    onVisibleChange(listener: (flag: boolean) => void): () => void;
+    onLockChange(listener: (flag: boolean) => void): () => void;
+    onChildrenChange(listener: (info?: {
+        type: string;
+        node: Node;
+    }) => void): (() => void) | undefined;
+    emitPropChange(prop: any): void;
+    onPropChange(listener: (info: any) => void): () => void;
+}
+export declare const isNode: (node: any) => node is Node;
+export declare const isNodeSchema: (data: any) => data is NodeSchema;
+/**
+ * get the top node of the same zLevel
+ */
+export declare const getZLevelTop: (child: Node, zLevel: number) => Node | null;
+/**
+ * check if node1 contains node2
+ */
+export declare const contains: (node1: Node, node2: Node) => boolean;
+export declare enum PositionNO {
+    Contains = 16,
+    ContainedBy = 8,
+    BeforeOrAfter = 2,
+    TheSame = 0
+}
+/**
+ * compare the position of two nodes
+ */
+export declare const comparePosition: (node1: Node, node2: Node) => PositionNO;
+export declare const insertChild: (container: Node, thing: Node | NodeSchema, at?: number | null, copy?: boolean) => Node | null;
+export declare const insertChildren: (container: Node, nodes: Node[] | NodeSchema[], at?: number | null, copy?: boolean) => Node[];
+/**
+ * get the closest node that satisfies the condition
+ */
+export declare const getClosestNode: (node: Node | null, until: (n: Node) => boolean) => Node | undefined;
+/**
+ * get the closest clickable node
+ */
+export declare const getClosestClickableNode: (currentNode: Node | undefined | null, event: MouseEvent) => Node<NodeSchema> | null | undefined;
+/**
+ * ensure the node is a Node instance
+ */
+export declare const ensureNode: (node: any, document: Document) => Node;

package/dist/document/prop/prop.d.ts

@@ -0,0 +1,185 @@
+import type { NodeSchema } from '../../types';
+import type { Node } from '../node/node';
+import type { Props } from './props';
+import { TRANSFORM_STAGE } from '../../types';
+export declare const UNSET: unique symbol;
+export type UNSET = typeof UNSET;
+export type ValueTypes = 'unset' | 'literal' | 'list' | 'map' | 'expression';
+/**
+ * a common interface for Prop and Props
+ */
+export interface PropParent {
+    readonly props: Props;
+    readonly owner: Node;
+    get path(): string[];
+    delete(prop: Prop): void;
+}
+export type PropKey = string | number;
+export type PropValue = CompositeValue;
+export type PropsMap = CompositeObject<NodeSchema | NodeSchema[]>;
+export type CompositeValue = JSONValue | CompositeArray | CompositeObject | JSExpression | JSFunction;
+export type CompositeArray = CompositeValue[];
+export interface CompositeObject<T = CompositeValue> {
+    [key: PropKey]: CompositeValue | T;
+}
+export type JSONValue = boolean | string | number | null | undefined | JSONArray | JSONObject;
+export type JSONArray = JSONValue[];
+export interface JSONObject {
+    [key: PropKey]: JSONValue;
+}
+export interface JSExpression {
+    type: 'JSExpression';
+    /**
+     * 表达式字符串
+     */
+    value: string;
+    /**
+     * 模拟值
+     */
+    mock?: any;
+    /**
+     * 源码
+     */
+    compiled?: string;
+}
+export interface JSFunction {
+    type: 'JSFunction';
+    /**
+     * 函数定义，或直接函数表达式
+     */
+    value: string;
+    /**
+     * 源码
+     */
+    compiled?: string;
+    /**
+     * 模拟值
+     */
+    mock?: any;
+    /**
+     * 额外扩展属性，如 extType、events
+     */
+    [key: string]: any;
+}
+export declare const isJSExpression: (data: any) => data is JSExpression;
+export declare function isJSFunction(data: any): data is JSFunction;
+export declare class Prop {
+    readonly parent: PropParent;
+    readonly isProp = true;
+    readonly id: string;
+    accessor key: PropKey;
+    readonly owner: Node;
+    getNode(): Node<NodeSchema>;
+    readonly props: Props;
+    getProps(): Props;
+    private accessor _value;
+    get value(): unknown | UNSET;
+    private _code;
+    /**
+     * 获得表达式值
+     */
+    get code(): string;
+    /**
+     * 设置表达式值
+     */
+    set code(code: string);
+    private accessor _type;
+    get type(): ValueTypes;
+    /** use for list or map type */
+    private accessor _items;
+    /**
+     * 作为一层缓存机制，主要是复用部分已存在的 Prop，保持响应式关系，比如：
+     * 当前 Prop#_value 值为 { a: 1 }，当调用 setValue({ a: 2 }) 时，所有原来的子 Prop 均被销毁，
+     * 导致假如外部有 mobx reaction（常见于 observer），此时响应式链路会被打断，
+     * 因为 reaction 监听的是原 Prop(a) 的 _value，而不是新 Prop(a) 的 _value。
+     */
+    private accessor _maps;
+    /**
+     * Construct the items and maps for the prop value
+     */
+    private get items();
+    private get maps();
+    /**
+     * return a path of prop
+     */
+    get path(): string[];
+    /**
+     * item length
+     */
+    get size(): number;
+    constructor(parent: PropParent, key: PropKey, value?: PropValue | UNSET);
+    /**
+     * This is to trigger the execution of the items getter function,
+     * which will construct the items and maps for the prop value
+     */
+    initItems(): void;
+    export(stage?: TRANSFORM_STAGE): PropValue;
+    /**
+     * whether the prop has been destroyed
+     */
+    private accessor purged;
+    /**
+     * clear internal data
+     */
+    purge(): void;
+    remove(): void;
+    /**
+     * dispose internal data, use for changing value,
+     * this will not trigger reactive
+     */
+    private dispose;
+    unset(): void;
+    isUnset(): boolean;
+    /**
+     * @returns  0: the same 1: maybe & like 2: not the same
+     */
+    compare(other: Prop | null): number;
+    /**
+     * set value, val should be JSON Object
+     */
+    setValue(val: PropValue): void;
+    getValue(): unknown;
+    getAsString(): string;
+    get(path: PropKey, createIfNone?: boolean): Prop | null;
+    set(key: PropKey, value: PropValue | Prop, force?: boolean): Prop | null;
+    delete(prop: Prop): void;
+    add(key: PropKey, value?: PropValue | UNSET, force?: boolean): Prop | null;
+    /**
+     * check if the prop has the key, only for map and list type
+     */
+    has(key: PropKey): boolean;
+    deleteKey(key: PropKey): void;
+    /**
+     * @see SettingTarget
+     */
+    getPropValue(key: PropKey): any;
+    /**
+     * @see SettingTarget
+     */
+    setPropValue(key: PropKey, value: any): void;
+    /**
+     * @see SettingTarget
+     */
+    clearPropValue(key: PropKey): void;
+    forEach(fn: (item: Prop, key: PropKey | number) => void): void;
+    map<T>(fn: (item: Prop, key: PropKey | number) => T): T[] | null;
+    [Symbol.iterator](): {
+        next(): {
+            value: Prop;
+        };
+    };
+}
+export declare const isProp: (obj: any) => obj is Prop;
+/**
+ * split path to entry and nest
+ * - entry: a or 0
+ * - nest: .b or [1].b
+ */
+export declare const splitPath: (path: PropKey) => {
+    entry: PropKey;
+    nest: string;
+};
+/**
+ * check if the key is a valid array index
+ */
+export declare function isValidArrayIndex(key: any, limit?: number): key is number;

package/dist/document/prop/props.d.ts

@@ -0,0 +1,57 @@
+import type { Node } from '../node/node';
+import type { PropKey, PropValue, PropsMap } from './prop';
+import { TRANSFORM_STAGE } from '../../types';
+import { Prop, UNSET } from './prop';
+/**
+ * prop key convert to extra key
+ */
+export declare const getConvertedExtraKey: (key: string) => string;
+/**
+ * extra key convert to prop key
+ */
+export declare const getOriginalExtraKey: (key: string) => string;
+export declare const isExtraKey: (key: string) => boolean;
+export declare class Props {
+    readonly id: string;
+    readonly path: never[];
+    readonly owner: Node;
+    getNode(): Node<import("../..").NodeSchema>;
+    get props(): this;
+    getProps(): this;
+    accessor type: string;
+    accessor items: Prop[];
+    private get maps();
+    get size(): number;
+    constructor(owner: Node, props?: PropsMap, extras?: PropsMap);
+    import(props?: PropsMap | null, extras?: PropsMap): void;
+    export(stage?: TRANSFORM_STAGE): {
+        props?: undefined;
+        extras?: undefined;
+    } | {
+        props: PropsMap;
+        extras: PropsMap;
+    };
+    merge(value: PropsMap, extras?: PropsMap): void;
+    private purged;
+    purge(): void;
+    /**
+     * get a prop, if not found, create a prop when createIfNone is true
+     */
+    get(path: PropKey, createIfNone?: boolean): Prop | null;
+    query(path: PropKey, createIfNone?: boolean): Prop | null;
+    getProp(path: PropKey, createIfNone?: boolean): Prop | null;
+    getPropValue(path: PropKey): unknown;
+    setPropValue(path: PropKey, value: any): void;
+    delete(prop: Prop): void;
+    deleteKey(key: PropKey): void;
+    add(key: PropKey, value?: PropValue | UNSET): Prop;
+    has(key: PropKey): boolean;
+    forEach(fn: (item: Prop, key: PropKey) => void): void;
+    map<E>(fn: (item: Prop, key: PropKey) => E): E[] | null;
+    filter(fn: (item: Prop, key: PropKey) => boolean): Prop[];
+    [Symbol.iterator](): {
+        next(): {
+            value: Prop;
+        };
+    };
+}

package/dist/document/prop/value-to-source.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 将 JavaScript 值转换为字符串格式
+ * @param value
+ * @param param1
+ * @returns
+ */
+export declare const valueToSource: (value: any, { circularReferenceToken, doubleQuote, includeFunctions, includeUndefinedProperties, indentLevel, indentString, lineEnding, visitedObjects, }?: any) => any;
+export declare const getSource: (value: any) => string;

package/dist/editor.d.ts

@@ -0,0 +1,94 @@
+import type { Component, ComponentMetadata } from './designer';
+import type { Plugin } from './plugin';
+import type { Setter } from './setter-manager';
+import type { ProjectSchema } from './types';
+import { type DesignerProps } from './designer';
+import { PluginManager } from './plugin';
+import { type HotkeyConfig } from './utils';
+export type EditorValueKey = string | symbol;
+export type EditorGetResult<T, ClsType> = T extends undefined ? ClsType extends {
+    prototype: infer R;
+} ? R : any : T;
+export interface EditorConfig {
+    /**
+     * 插件 Plugin
+     */
+    plugins?: Plugin[];
+    /**
+     * 设置器 Setter
+     */
+    setters?: Record<string, Setter>;
+    /**
+     * 组件 Component
+     */
+    components?: Record<string, Component>;
+    /**
+     * 组件元数据 ComponentMetadata
+     */
+    componentMetas?: Record<string, ComponentMetadata>;
+    /**
+     * 生命周期
+     */
+    lifeCycles?: LifeCyclesConfig;
+    /**
+     * designer props
+     */
+    designer?: Pick<DesignerProps, 'onDragstart' | 'onDrag' | 'onDragend'>;
+    /**
+     * 默认项目 Schema
+     */
+    defaultSchema?: ProjectSchema;
+    /**
+     * 快捷键
+     */
+    hotkeys?: HotkeyConfig[];
+}
+export interface LifeCyclesConfig {
+    init?: (editor: Editor) => any;
+    destroy?: (editor: Editor) => any;
+    extend?: (editor: Editor) => any;
+}
+export declare enum EDITOR_EVENT {
+    BEFORE_INIT = "editor:beforeInit",
+    AFTER_INIT = "editor:afterInit",
+    DESTROY = "editor:destroy",
+    BEFORE_EXTEND = "editor:beforeExtend",
+    AFTER_EXTEND = "editor:afterExtend"
+}
+export declare class Editor {
+    private accessor context;
+    config?: EditorConfig;
+    eventBus: import("./utils").EventBus;
+    private waits;
+    constructor(config?: EditorConfig);
+    get<T = undefined, KeyOrType extends EditorValueKey = any>(keyOrType: KeyOrType): EditorGetResult<T, KeyOrType> | undefined;
+    has(keyOrType: EditorValueKey): boolean;
+    set(key: EditorValueKey, data: any): void | Promise<void>;
+    /**
+     * get value until value is set
+     */
+    onceGot<T = undefined, KeyOrType extends EditorValueKey = any>(keyOrType: KeyOrType): Promise<EditorGetResult<T, KeyOrType>>;
+    /**
+     * listen value when value is set
+     */
+    onGot<T = undefined, KeyOrType extends EditorValueKey = any>(keyOrType: KeyOrType, fn: (data: EditorGetResult<T, KeyOrType>) => void): () => void;
+    /**
+     * listen value when value is changed
+     */
+    onChange<T = undefined, KeyOrType extends EditorValueKey = any>(keyOrType: KeyOrType, fn: (data: EditorGetResult<T, KeyOrType>) => void): () => void;
+    init(config?: EditorConfig): Promise<void>;
+    destroy(): void;
+    extend(pluginManager: PluginManager): Promise<void>;
+    /**
+     * notify all listeners when value is got
+     */
+    private notifyGot;
+    private setWait;
+    private delWait;
+    onBeforeInit(listener: (editor: Editor) => void): () => void;
+    onAfterInit(listener: (editor: Editor) => void): () => void;
+    onDestroy(listener: (editor: Editor) => void): () => void;
+    onBeforeExtend(listener: (editor: Editor) => void): () => void;
+    onAfterExtend(listener: (editor: Editor) => void): () => void;
+}
+export declare const createEasyEditor: (config?: EditorConfig) => Editor;