@easy-editor/core 0.0.1

package/dist/plugin/index.d.ts

@@ -0,0 +1,3 @@
+export * from './plugin-context';
+export * from './plugin-manager';
+export * from './plugin-runtime';

package/dist/plugin/plugin-context.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentMetaManager, Designer, Editor, Project, SetterManager, Simulator } from '..';
+import type { EventBus, Hotkey, Logger } from '../utils';
+import type { PluginContextApiAssembler, PluginMeta } from './plugin-manager';
+export interface PluginContextOptions {
+    pluginName: string;
+    meta?: PluginMeta;
+}
+export declare class PluginContext {
+    editor: Editor;
+    simulator: Simulator;
+    designer: Designer;
+    project: Project;
+    setterManager: SetterManager;
+    componentMetaManager: ComponentMetaManager;
+    logger: Logger;
+    event: EventBus;
+    pluginEvent: EventBus;
+    hotkey: Hotkey;
+    constructor(options: PluginContextOptions, contextApiAssembler: PluginContextApiAssembler);
+}

package/dist/plugin/plugin-extend.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentMeta, ComponentMetaManager, Designer, Detecting, Document, Dragon, DropLocation, History, Node, NodeChildren, OffsetObserver, Project, Prop, Props, Selection, SetterManager, Simulator, Viewport } from '..';
+export interface PluginExtend {
+    extendClass: PluginExtendClass;
+    extend: <T extends keyof PluginExtendClass>(extendClass: T, properties: Record<PropertyKey, () => any> | (PropertyDescriptorMap & ThisType<InstanceType<PluginExtendClass[T]>>)) => void;
+}
+export interface PluginExtendClass {
+    Simulator: typeof Simulator;
+    Viewport: typeof Viewport;
+    Designer: typeof Designer;
+    Dragon: typeof Dragon;
+    Detecting: typeof Detecting;
+    Selection: typeof Selection;
+    DropLocation: typeof DropLocation;
+    OffsetObserver: typeof OffsetObserver;
+    Project: typeof Project;
+    Document: typeof Document;
+    History: typeof History;
+    Node: typeof Node;
+    NodeChildren: typeof NodeChildren;
+    Props: typeof Props;
+    Prop: typeof Prop;
+    ComponentMetaManager: typeof ComponentMetaManager;
+    SetterManager: typeof SetterManager;
+    ComponentMeta: typeof ComponentMeta;
+}
+/**
+ * 扩展类
+ * @param extendMap 扩展类映射
+ * @param extendClass 扩展类
+ * @param properties 扩展属性
+ */
+export declare const extend: <T extends keyof PluginExtendClass>(extendMap: Record<T, PluginExtendClass[T]>, extendClass: T, properties: Record<PropertyKey, () => any> | (PropertyDescriptorMap & ThisType<InstanceType<PluginExtendClass[T]>>)) => void;

package/dist/plugin/plugin-manager.d.ts

@@ -0,0 +1,78 @@
+import type { PluginContextOptions } from './plugin-context';
+import { type PluginExtend } from './plugin-extend';
+import { PluginContext } from './plugin-context';
+import { PluginRuntime } from './plugin-runtime';
+export interface Plugin {
+    name: string;
+    deps?: string[];
+    eventPrefix?: string;
+    init(ctx: PluginContext): Promise<void> | void;
+    destroy?(ctx: PluginContext): Promise<void> | void;
+    extend?(ctx: PluginExtend): void;
+}
+export interface PluginMeta {
+    /**
+     * define dependencies which the plugin depends on
+     */
+    dependencies?: string[];
+    /**
+     * use 'common' as event prefix when eventPrefix is not set.
+     */
+    eventPrefix?: string;
+}
+export type PluginCreator<O = any> = (options?: O) => Plugin;
+export interface PluginRegisterOptions {
+    /**
+     * Will enable plugin registered with auto-initialization immediately
+     * other than plugin-manager init all plugins at certain time.
+     * It is helpful when plugin register is later than plugin-manager initialization.
+     */
+    autoInit?: boolean;
+    /**
+     * allow overriding existing plugin with same name when override === true
+     */
+    override?: boolean;
+}
+/**
+ * Assemble APIs for plugins to create context
+ */
+export interface PluginContextApiAssembler {
+    assembleApis(context: PluginContext, pluginName: string, meta: PluginMeta): void;
+}
+export declare class PluginManager {
+    private plugins;
+    pluginsMap: Map<string, PluginRuntime>;
+    pluginContextMap: Map<string, PluginContext>;
+    private contextApiAssembler;
+    constructor(contextApiAssembler?: PluginContextApiAssembler);
+    setContextApiAssembler(contextApiAssembler: PluginContextApiAssembler): void;
+    getPluginContext: (options: PluginContextOptions) => PluginContext;
+    /**
+     * register a plugin
+     * @param pluginConfigCreator - a creator function which returns the plugin config
+     * @param options - the plugin options
+     * @param registerOptions - the plugin register options
+     */
+    register(pluginModel: Plugin, registerOptions?: PluginRegisterOptions): Promise<void>;
+    /**
+     * batch register plugins
+     */
+    registerPlugins(plugins: Plugin[], registerOptions?: PluginRegisterOptions): Promise<void>;
+    get(pluginName: string): PluginRuntime | undefined;
+    getAll(): PluginRuntime[];
+    has(pluginName: string): boolean;
+    delete(pluginName: string): Promise<boolean>;
+    init(): Promise<void>;
+    /**
+     * destroy all plugins
+     */
+    destroy(): Promise<void>;
+    extend(): Promise<void>;
+    get size(): number;
+    setDisabled(pluginName: string, flag?: boolean): void;
+    /**
+     * reset plugin manager
+     */
+    dispose(): Promise<void>;
+}
+export declare const isRegisterOptions: (opts: any) => opts is PluginRegisterOptions;

package/dist/plugin/plugin-runtime.d.ts

@@ -0,0 +1,28 @@
+import { type Logger } from '../utils';
+import type { PluginExtend } from './plugin-extend';
+import type { Plugin, PluginManager, PluginMeta } from './plugin-manager';
+export declare class PluginRuntime {
+    config: Plugin;
+    logger: Logger;
+    private manager;
+    private _inited;
+    private _extended;
+    private pluginName;
+    meta: PluginMeta;
+    /**
+     * indicates whether the plugin is disabled
+     */
+    private _disabled;
+    get ctx(): import("./plugin-context").PluginContext;
+    constructor(pluginName: string, manager: PluginManager, config: Plugin);
+    get name(): string;
+    get deps(): string[];
+    get disabled(): boolean;
+    isInited(): boolean;
+    isExtended(): boolean;
+    init(forceInit?: boolean): Promise<void>;
+    destroy(): Promise<void>;
+    extend(pluginExtend: PluginExtend): Promise<void>;
+    setDisabled(flag?: boolean): void;
+    dispose(): Promise<void>;
+}

package/dist/plugin/sequencify.d.ts

@@ -0,0 +1,19 @@
+type Tasks = Record<string, {
+    name: string;
+    deps: string[];
+}>;
+export declare function sequence({ tasks, names, results, missing, recursive, nest, parentName, }: {
+    tasks: Tasks;
+    names: string[];
+    results: string[];
+    missing: string[];
+    recursive: string[][];
+    nest: string[];
+    parentName: string;
+}): void;
+export default function (tasks: Tasks, names: string[]): {
+    sequence: string[];
+    missingTasks: string[];
+    recursiveDependencies: string[][];
+};
+export {};

package/dist/project/index.d.ts

@@ -0,0 +1 @@
+export * from './project';

package/dist/project/project.d.ts

@@ -0,0 +1,68 @@
+import type { Designer } from '../designer';
+import type { Simulator } from '../simulator';
+import type { ProjectSchema, RootSchema } from '../types';
+import { Document } from '../document';
+import { TRANSFORM_STAGE } from '../types';
+export declare enum PROJECT_EVENT {
+    RENDERER_READY = "renderer:ready",
+    SIMULATOR_READY = "simulator:ready"
+}
+export declare class Project {
+    readonly designer: Designer;
+    private emitter;
+    private data;
+    accessor documents: Document[];
+    private documentsMap;
+    get currentDocument(): Document | undefined;
+    private accessor _config;
+    get config(): Record<string, any> | undefined;
+    set config(value: Record<string, any>);
+    private _simulator?;
+    get simulator(): Simulator | null;
+    constructor(designer: Designer, schema?: ProjectSchema);
+    import(schema: ProjectSchema): void;
+    export(stage?: TRANSFORM_STAGE): ProjectSchema;
+    private getComponentsMap;
+    /**
+     * load project schema
+     * @param schema project schema
+     * @param autoOpen auto open document, if type is string, will open document by id, if type is boolean, will open first document
+     */
+    load(schema?: ProjectSchema, autoOpen?: boolean | string): void;
+    unload(): void;
+    createDocument(schema?: RootSchema): Document;
+    removeDocument(idOrDoc: string | Document): void;
+    getDocument(id: string): Document | undefined;
+    /**
+     * open or create a document
+     */
+    open(idOrDoc?: string | Document | RootSchema): Document | null;
+    /**
+     * suspense other documents
+     * @param curDoc current active document
+     */
+    checkExclusive(curDoc: Document): void;
+    closeOthers(opened: Document): void;
+    /**
+     * set extra data, available for plugins
+     */
+    set<T extends keyof ProjectSchema>(key: T, value: ProjectSchema[T]): void;
+    set(key: string, value: unknown): void;
+    /**
+     * get extra data, available for plugins
+     */
+    get<T extends keyof ProjectSchema>(key: T): ProjectSchema[T];
+    get<T>(key: string): T;
+    get(key: string): unknown;
+    private isRendererReady;
+    setRendererReady(renderer: any): void;
+    mountSimulator(simulator: Simulator): void;
+    onSimulatorReady(listener: (simulator: Simulator) => void): () => void;
+    /**
+     * use to wait for renderer ready and then do initial work
+     */
+    onRendererReady(listener: () => void): () => void;
+    onDocumentAdd(listener: (document: Document) => void): () => void;
+    onDocumentRemove(listener: (id: string) => void): () => void;
+    onCurrentDocumentChange(listener: (document: Document) => void): () => void;
+}

package/dist/setter-manager/index.d.ts

@@ -0,0 +1 @@
+export * from './setter-manager';

package/dist/setter-manager/setter-manager.d.ts

@@ -0,0 +1,29 @@
+import type { Component } from '../designer';
+/**
+ * for setter component props
+ */
+export interface SetterProps<T = unknown> {
+    value: T;
+    onChange: (val: T) => void;
+}
+export interface Setter {
+    component: Component;
+    defaultProps?: object;
+    name?: string;
+}
+interface RegisterSetterOption {
+    overwrite?: boolean;
+}
+export declare class SetterManager {
+    private _settersMap;
+    get settersMap(): Map<string, Setter & {
+        type: string;
+    }>;
+    getSetter(type: string): (Setter & {
+        type: string;
+    }) | undefined;
+    buildSettersMap: (setters: Record<string, Setter>) => void;
+    registerSetter(type: string, setter: Component | Setter, option?: RegisterSetterOption): void;
+    createSetterContent: (setter: any, props: Record<string, any>) => Component;
+}
+export {};

package/dist/simulator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './simulator';
+export * from './simulator-renderer';
+export * from './viewport';

package/dist/simulator/simulator-renderer.d.ts

@@ -0,0 +1,41 @@
+import type { Node } from '..';
+import type { Component, ComponentInstance, NodeInstance } from '../designer';
+export interface SimulatorRenderer {
+    readonly isSimulatorRenderer: true;
+    /**
+     * 是否自动重绘节点
+     */
+    autoRepaintNode?: boolean;
+    /**
+     * 组件列表
+     */
+    components: Record<string, Component>;
+    /**
+     * 重新渲染
+     */
+    rerender: () => void;
+    /**
+     * 获取组件
+     */
+    getComponent(componentName: string): Component;
+    /**
+     * 获取最近的节点实例
+     */
+    getClosestNodeInstance(from: ComponentInstance, nodeId?: string): NodeInstance<ComponentInstance, Node> | null;
+    /**
+     * 获取元素的 Rect 信息
+     */
+    getClientRects(element: Element | Text): DOMRect[];
+    /**
+     * 关闭自动重绘节点
+     */
+    stopAutoRepaintNode(): void;
+    /**
+     * 开启自动重绘节点
+     */
+    enableAutoRepaintNode(): void;
+    /**
+     * 渲染器启动
+     */
+    run(): void;
+}

package/dist/simulator/simulator.d.ts

@@ -0,0 +1,106 @@
+import type { IReactionDisposer, IReactionOptions, IReactionPublic } from 'mobx';
+import type { Component, ComponentInstance, Designer, LocateEvent, NodeInstance, Snippet } from '../designer';
+import type { Node } from '../document';
+import type { Project } from '../project';
+import type { SimulatorRenderer } from './simulator-renderer';
+import { Viewport } from './viewport';
+export interface DropContainer {
+    container: Node;
+    instance: ComponentInstance;
+}
+export type DesignMode = 'design' | 'preview' | 'live';
+export type Device = 'mobile' | 'iphone' | 'pc' | string;
+export interface SimulatorProps {
+    designMode?: DesignMode;
+    device?: Device;
+    deviceClassName?: string;
+    requestHandlersMap?: any;
+    [key: string]: any;
+}
+export interface DeviceStyleProps {
+    canvas?: object;
+    viewport?: object;
+    content?: object;
+}
+export declare class Simulator {
+    readonly emitter: import("..").EventBus;
+    isSimulator: boolean;
+    readonly project: Project;
+    readonly designer: Designer;
+    readonly viewport: Viewport;
+    iframe?: HTMLElement;
+    autoRender: boolean;
+    get editor(): import("..").Editor;
+    get device(): string;
+    get requestHandlersMap(): any;
+    get thisRequiredInJSE(): boolean;
+    get enableStrictNotFoundMode(): any;
+    get notFoundComponent(): any;
+    get faultComponent(): any;
+    get designMode(): DesignMode;
+    get deviceStyle(): DeviceStyleProps | undefined;
+    get componentsMap(): {
+        [key: string]: any;
+    };
+    accessor _props: SimulatorProps;
+    private accessor _contentWindow;
+    get contentWindow(): Window | undefined;
+    private accessor _contentDocument;
+    get contentDocument(): Document | undefined;
+    private accessor _components;
+    /**
+     * material to component map
+     */
+    get components(): Record<string, any>;
+    private accessor instancesMap;
+    private _sensorAvailable;
+    get sensorAvailable(): boolean;
+    private _renderer?;
+    get renderer(): SimulatorRenderer | undefined;
+    private sensing;
+    get currentDocument(): import("..").Document | undefined;
+    constructor(designer: Designer);
+    setProps(props: SimulatorProps): void;
+    set(key: string, value: any): void;
+    get(key: string): any;
+    connect(renderer: SimulatorRenderer, effect: (reaction: IReactionPublic) => void, options?: IReactionOptions<unknown, boolean>): IReactionDisposer;
+    reaction(expression: (reaction: IReactionPublic) => unknown, effect: (value: unknown, prev: unknown, reaction: IReactionPublic) => void, opts?: IReactionOptions<unknown, boolean>): IReactionDisposer;
+    autorun(effect: (reaction: IReactionPublic) => void, options?: IReactionOptions<unknown, boolean>): IReactionDisposer;
+    purge(): void;
+    /**
+     * force to rerender the viewport
+     */
+    rerender(): void;
+    mountContentFrame(iframe: HTMLIFrameElement | HTMLElement | null): void;
+    getComponent(componentName: string): any;
+    postEvent(eventName: string, ...data: any[]): void;
+    linkSnippet(ref: HTMLElement, snippet: Snippet): () => void;
+    setupEvents(): void;
+    setupDragAndClick(): void;
+    setupDetecting(): void;
+    buildComponentMap(components: Record<string, Component>): void;
+    addComponent(name: string, component: Component, override?: boolean): void;
+    setInstance(docId: string, id: string, instances: ComponentInstance[] | null): void;
+    getInstance(docId: string, id: string): any;
+    getComponentInstances(node: Node, context?: NodeInstance<ComponentInstance, Node>): ComponentInstance | null;
+    getClosestNodeInstance(from: ComponentInstance, specId?: string): NodeInstance<ComponentInstance> | null;
+    computeRect(node: Node): DOMRect | null | undefined;
+    computeComponentInstanceRect(instance: ComponentInstance, selector?: string): DOMRect | undefined;
+    getNodeInstanceFromElement(target: Element | null): NodeInstance<ComponentInstance, Node> | null;
+    /**
+     * fix event's prop, canvasX、canvasY and target
+     */
+    fixEvent(e: LocateEvent): LocateEvent;
+    /**
+     * check the rect whether is in the viewport
+     */
+    isEnter(e: LocateEvent): boolean;
+    deactiveSensor(): void;
+    locate(e: LocateEvent): any;
+    /**
+     * find the suitable drop container
+     */
+    getDropContainer(e: LocateEvent): DropContainer | null;
+    handleAccept({ container }: DropContainer, e: LocateEvent): boolean;
+}
+export declare const isSimulator: (obj: any) => obj is Simulator;

package/dist/simulator/viewport.d.ts

@@ -0,0 +1,29 @@
+import { type Designer, type Point } from '../designer';
+export type AutoFit = '100%';
+export declare const AutoFit: AutoFit;
+export declare class Viewport {
+    readonly designer: Designer;
+    private accessor rect;
+    private _bounds?;
+    get bounds(): DOMRect;
+    get contentBounds(): DOMRect;
+    private viewportElement?;
+    constructor(designer: Designer);
+    mount(viewportElement: HTMLElement | null): void;
+    touch(): void;
+    get height(): number;
+    set height(newHeight: number);
+    get width(): number;
+    set width(newWidth: number);
+    private accessor _scale;
+    get scale(): number;
+    set scale(newScale: number);
+    private accessor _contentWidth;
+    private accessor _contentHeight;
+    get contentHeight(): number | AutoFit;
+    set contentHeight(newContentHeight: number | AutoFit);
+    get contentWidth(): number | AutoFit;
+    set contentWidth(val: number | AutoFit);
+    toGlobalPoint(point: Point): Point;
+    toLocalPoint(point: Point): Point;
+}

package/dist/types/common.d.ts

@@ -0,0 +1,11 @@
+/**
+ * transform stage, use for export
+ */
+export declare enum TRANSFORM_STAGE {
+    RENDER = "render",
+    SERIALIZE = "serialize",
+    SAVE = "save",
+    CLONE = "clone",
+    INIT = "init",
+    UPGRADE = "upgrade"
+}

package/dist/types/event.d.ts

@@ -0,0 +1,12 @@
+import { DESIGNER_EVENT, DETECTING_EVENT, DOCUMENT_EVENT, DRAGON_EVENT, EDITOR_EVENT, NODE_CHILDREN_EVENT, NODE_EVENT, PROJECT_EVENT, SELECTION_EVENT } from '..';
+export declare const GLOBAL_EVENT: {
+    EDITOR_EVENT: typeof EDITOR_EVENT;
+    DESIGNER_EVENT: typeof DESIGNER_EVENT;
+    DRAGON_EVENT: typeof DRAGON_EVENT;
+    DETECTING_EVENT: typeof DETECTING_EVENT;
+    SELECTION_EVENT: typeof SELECTION_EVENT;
+    PROJECT_EVENT: typeof PROJECT_EVENT;
+    DOCUMENT_EVENT: typeof DOCUMENT_EVENT;
+    NODE_EVENT: typeof NODE_EVENT;
+    NODE_CHILDREN_EVENT: typeof NODE_CHILDREN_EVENT;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './event';
+export * from './schema';

package/dist/types/schema.d.ts

@@ -0,0 +1,64 @@
+import type { CompositeValue, JSExpression, JSFunction, JSONObject, PropsMap } from '../document';
+export interface ProjectSchema<T = RootSchema> {
+    id?: string;
+    version: string;
+    componentsMap?: any;
+    componentsTree: T[];
+    utils?: Record<string, any>;
+    constants?: JSONObject;
+    css?: string;
+    config?: Record<string, any>;
+    meta?: Record<string, any>;
+    [key: string]: any;
+}
+export interface RootSchema extends NodeSchema {
+    docId?: string;
+    /**
+     * 文件名称
+     */
+    fileName?: string;
+    meta?: Record<string, unknown>;
+    /**
+     * 容器初始数据
+     */
+    state?: {
+        [key: string]: CompositeValue;
+    };
+    /**
+     * 自定义方法设置
+     */
+    methods?: {
+        [key: string]: JSExpression | JSFunction;
+    };
+    /**
+     * 生命周期对象
+     */
+    lifeCycles?: {
+        [key: string]: JSExpression | JSFunction;
+    };
+    /**
+     * 样式文件
+     */
+    css?: string;
+}
+export interface NodeSchema {
+    id?: string;
+    /** title */
+    title?: string;
+    /** required */
+    componentName: string;
+    /** props */
+    props?: PropsMap;
+    /** sub nodes */
+    children?: NodeSchema[];
+    /** hidden */
+    hidden?: boolean;
+    /** locked */
+    locked?: boolean;
+    /** render condition */
+    condition?: CompositeValue;
+    /** loop data */
+    loop?: CompositeValue;
+    [key: string]: any;
+}
+export type NodeData = NodeSchema | JSExpression;

package/dist/utils/common.d.ts

@@ -0,0 +1 @@
+export declare const cloneDeep: (src: any) => any;

package/dist/utils/event-bus.d.ts

@@ -0,0 +1,45 @@
+type EventType = string | symbol;
+type Events = Record<EventType, unknown>;
+type Handler = (event: Events[keyof Events]) => void;
+declare class EventEmitter {
+    all: Map<EventType, Handler[]>;
+    on<Key extends keyof Events>(type: Key, handler: Handler): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler): void;
+    emit<Key extends keyof Events>(type: Key, evt?: Events[Key]): void;
+}
+export declare class EventBus {
+    private readonly eventEmitter;
+    private readonly name?;
+    private logger;
+    /**
+     * 内核触发的事件名
+     */
+    readonly names: never[];
+    constructor(emitter: EventEmitter, name?: string);
+    private getMsgPrefix;
+    /**
+     * 监听事件
+     * @param event 事件名称
+     * @param listener 事件回调
+     */
+    on(event: string, listener: (...args: any[]) => void): () => void;
+    /**
+     * 取消监听事件
+     * @param event 事件名称
+     * @param listener 事件回调
+     */
+    off(event: string, listener: (...args: any[]) => void): void;
+    /**
+     * 触发事件
+     * @param event 事件名称
+     * @param args 事件参数
+     * @returns
+     */
+    emit(event: string, ...args: any[]): void;
+}
+/**
+ * 创建一个独立模块事件总线
+ * @param name 模块名称
+ */
+export declare const createEventBus: (name: string) => EventBus;
+export {};