@easy-editor/core 0.0.15 → 1.0.0

package/README.md

@@ -1,38 +1,36 @@
 # @easy-editor/core
 
-Core engine package for EasyEditor.
+Core specification and type package for EasyEditor, a cross-framework low-code editor with a scalable architecture.
 
-## Features
-
-- **Decoupling Design**：Engine core is framework-independent, supporting multiple framework rendering extensions
-- **Visual Design**：Complete implementation of the designer, drag-and-drop layout, snapping alignment, multi-device preview, undo/redo stack...
-- **Plugin Architecture**：Flexible plugin system design, lifecycle management, hotkey binding, class extension mechanism, dependency injection...
-- **Rendering Engine**：Multi-framework support, real-time preview, Schema driven, component isolation sandbox
-- **Enterprise-level Capabilities**：Data source management, multi-language support, version control, online collaboration
+## Package Structure
 
-## Usage
+This package provides two main entry points:
 
-### Dashboard + React
+### 1. Main Entry Point (`@easy-editor/core`)
 
-1. Install
+The main entry point provides specifications, interfaces, and types:
+- Core interfaces and abstract classes
+- Type definitions for all components and modules
+- Base structures for plugins, documents, and components
+- Standard events and constants
+- Utility functions and helpers
 
-```bash
-pnpm install @easyeditor/core
-```
+### 2. Engine Entry Point (`@easy-editor/core/engine`)
 
-2. Init
+The engine entry point provides the concrete implementation that users should import and use directly:
+- Ready-to-use editor instance
+- Fully configured plugin system
+- Initialized core modules
+- Export of common services (designer, project, etc.)
+- Lifecycle management (init, destroy)
 
-```ts
-import { createEditor } from '@easyeditor/core'
-
-export const editor = createEasyEditor({
-  setters,
-  components,
-  componentMetas,
-})
+## Features
 
-// get core modules
-export const designer = await editor.onceGot<Designer>('designer')
-export const project = await editor.onceGot<Project>('project')
-export const simulator = await editor.onceGot<Simulator>('simulator')
-```
+- **Framework Agnostic**: Core is designed to work with any frontend framework
+- **Plugin Architecture**: Extensible system for adding features and capabilities
+- **Visual Design**: Complete designer implementation with drag-and-drop, alignment, and undo/redo
+- **Component Model**: Structured component definition and management system
+- **Event System**: Powerful event bus for communication between modules
+- **Configuration System**: Centralized config management with plugin integration
+- **Project Management**: Handles documents, history, serialization, and more
+- **Type Safety**: Comprehensive TypeScript definitions for all components

package/dist/config.d.ts

@@ -0,0 +1,131 @@
+import type { Component, DataSourceEngine } from './types';
+export interface ConfigOptions {
+    /**
+     * 是否开启 condition 的能力，默认在设计器中不管 condition 是啥都正常展示
+     * @default false
+     */
+    enableCondition?: boolean;
+    /**
+     * 设计模式，live 模式将会实时展示变量值
+     * @default 'design'
+     */
+    designMode?: 'design' | 'live';
+    /**
+     * 设备类型
+     * @default 'default'
+     */
+    device?: 'default' | 'mobile' | string;
+    /**
+     * 指定初始化的 deviceClassName，挂载到画布的顶层节点上
+     */
+    deviceClassName?: string;
+    /**
+     * 语言
+     * @default 'zh-CN'
+     */
+    locale?: string;
+    /**
+     * 渲染器类型
+     */
+    renderEnv?: 'react' | 'vue' | string;
+    /**
+     * 关闭画布自动渲染
+     * @default false
+     */
+    disableAutoRender?: boolean;
+    /**
+     * 容器锁定后，容器本身是否可以设置属性，仅当画布锁定特性开启时生效
+     * @default false
+     * @todo
+     */
+    enableLockedNodeSetting?: boolean;
+    /**
+     * 与 renderer 的 appHelper 一致
+     */
+    appHelper?: {
+        utils?: Record<string, any>;
+        constants?: Record<string, any>;
+        [key: string]: any;
+    };
+    /**
+     * 数据源引擎
+     */
+    dataSourceEngine?: DataSourceEngine;
+    /**
+     * 当开启组件未找到严格模式时，渲染模块不会默认给一个容器组件
+     * @default false
+     */
+    enableStrictNotFoundMode?: boolean;
+    /**
+     * 是否在设计态中执行生命周期，默认只在运行态执行
+     * @default false
+     */
+    excuteLifeCycleInDesignMode?: boolean;
+    /**
+     * 当找不到组件时显示的组件
+     */
+    notFoundComponent?: Component;
+    /**
+     * 当组件渲染异常时显示的组件
+     */
+    faultComponent?: Component;
+    /**
+     * 项目进行初始化加载时显示的组件
+     */
+    loadingComponent?: Component;
+}
+export declare class Config {
+    private config;
+    private waits;
+    constructor(config?: {
+        [key: string]: any;
+    });
+    /**
+     * 判断指定 key 是否有值
+     * @param key
+     */
+    has(key: string): boolean;
+    /**
+     * 获取指定 key 的值
+     * @param key
+     * @param defaultValue
+     */
+    get(key: string, defaultValue?: any): any;
+    /**
+     * 设置指定 key 的值
+     * @param key
+     * @param value
+     */
+    set(key: string, value: any): void;
+    /**
+     * 批量设值，set 的对象版本
+     * @param config
+     */
+    setConfig(config: {
+        [key: string]: any;
+    }): void;
+    /**
+     * if engineOptions.strictPluginMode === true, only accept propertied predefined in EngineOptions.
+     *
+     * @param {ConfigOptions} engineOptions
+     */
+    setEngineOptions(engineOptions: ConfigOptions): void;
+    /**
+     * 获取指定 key 的值，若此时还未赋值，则等待，若已有值，则直接返回值
+     *  注：此函数返回 Promise 实例，只会执行（fullfill）一次
+     * @param key
+     * @returns
+     */
+    onceGot(key: string): Promise<any>;
+    /**
+     * 获取指定 key 的值，函数回调模式，若多次被赋值，回调会被多次调用
+     * @param key
+     * @param fn
+     * @returns
+     */
+    onGot(key: string, fn: (data: any) => void): () => void;
+    notifyGot(key: string): void;
+    setWait(key: string, resolve: (data: any) => void, once?: boolean): void;
+    delWait(key: string, fn: any): void;
+}
+export declare const config: Config;

package/dist/designer/active-tracker.d.ts

@@ -0,0 +1,17 @@
+import { type Node } from '../document';
+import type { ComponentInstance } from '../types';
+import type { LocationDetail } from './location';
+export interface ActiveTarget {
+    node: Node;
+    detail?: LocationDetail;
+    instance?: ComponentInstance;
+}
+export declare class ActiveTracker {
+    private accessor _target;
+    private emitter;
+    track(originalTarget: ActiveTarget | Node): void;
+    get currentNode(): Node<import("..").NodeSchema>;
+    get detail(): LocationDetail | undefined;
+    get instance(): any;
+    onChange(fn: (target: ActiveTarget) => void): () => void;
+}

package/dist/designer/designer.d.ts

@@ -1,14 +1,14 @@
-import type { Node, PropsMap } from '../document';
-import type { Editor } from '../editor';
-import type { ProjectSchema, TRANSFORM_STAGE } from '../types';
-import type { ComponentMetaManager } from './component-meta';
-import type { DragObject } from './dragon';
-import type { LocateEvent, LocationData } from './location';
+import { type Node, type PropsMap } from '../document';
+import type { Materials } from '../materials';
 import { Project } from '../project';
+import type { ComponentMetadata, Editor, ProjectSchema, TRANSFORM_STAGE } from '../types';
+import { ActiveTracker } from './active-tracker';
 import { Detecting } from './detecting';
+import type { DragObject } from './dragon';
 import { Dragon } from './dragon';
-import { DropLocation } from './location';
+import { DropLocation, type LocateEvent, type LocationData } from './location';
 import { type NodeSelector, type OffsetObserver } from './offset-observer';
+import { type Scrollable, Scroller } from './scroller';
 import { Selection } from './selection';
 import { SettingsManager } from './setting';
 import { SettingTopEntry } from './setting/setting-top-entry';
@@ -18,6 +18,11 @@ export type PropsTransducer = (props: PropsMap, node: Node, ctx?: {
 export interface DesignerProps {
     editor: Editor;
     defaultSchema?: ProjectSchema;
+    hotkeys?: object;
+    simulatorProps?: Record<string, any> | ((project: Project) => object);
+    suspended?: boolean;
+    componentMetadatas?: ComponentMetadata[];
+    onMount?: (designer: Designer) => void;
     onDragstart?: (e: LocateEvent) => void;
     onDrag?: (e: LocateEvent) => void;
     onDragend?: (e: {
@@ -27,14 +32,17 @@ export interface DesignerProps {
     [key: string]: any;
 }
 export declare enum DESIGNER_EVENT {
+    MOUNT = "designer:mount",
     INIT = "designer:init",
     DRAG_START = "designer:dragstart",
     DRAG = "designer:drag",
     DRAG_END = "designer:dragend",
-    CURRENT_DOCUMENT_CHANGE = "designer:current-document.change",
-    CURRENT_HISTORY_CHANGE = "designer:current-history.change",
     DROP_LOCATION_CHANGE = "designer:dropLocation.change",
     DOCUMENT_DROP_LOCATION_CHANGE = "designer:document.dropLocation.change",
+    SETTING_TOP_ENTRY_VALUE_CHANGE = "designer:setting.top-entry.value.change",
+    SELECTION_CHANGE = "designer:selection.change",
+    CURRENT_DOCUMENT_CHANGE = "designer:current-document.change",
+    CURRENT_HISTORY_CHANGE = "designer:current-history.change",
     INSERT_NODE_BEFORE = "designer:node.insert.before",
     INSERT_NODE_AFTER = "designer:node.insert.after",
     NODE_VISIBLE_CHANGE = "designer:node.visible.change",
@@ -43,13 +51,12 @@ export declare enum DESIGNER_EVENT {
     NODE_PROPS_CHANGE = "designer:node.props.change",
     NODE_REMOVE = "designer:node.remove",
     NODE_RENDER = "designer:node.render",
-    SETTING_TOP_ENTRY_VALUE_CHANGE = "designer:setting.top-entry.value.change",
-    SELECTION_CHANGE = "designer:selection.change",
     SIMULATOR_SELECT = "designer:simulator.select",
     VIEWPORT_MOUNT = "simulator:viewport.mount"
 }
 export declare class Designer {
     private emitter;
+    readonly activeTracker: ActiveTracker;
     readonly editor: Editor;
     readonly dragon: Dragon;
     readonly detecting: Detecting;
@@ -57,10 +64,12 @@ export declare class Designer {
     readonly selection: Selection;
     readonly settingsManager: SettingsManager;
     private _dropLocation?;
-    get componentMetaManager(): ComponentMetaManager;
+    get materials(): Materials;
     private props?;
     private propsReducers;
     private oobxList;
+    private accessor _simulatorProps;
+    private accessor _suspended;
     get currentDocument(): import("..").Document | undefined;
     get currentHistory(): import("..").History<import("..").RootSchema> | undefined;
     constructor(props: DesignerProps);
@@ -68,19 +77,28 @@ export declare class Designer {
      * 该函数用于 Designer constructor 的插件扩展，因为 Object.defineProperty 无法修改 constructor
      */
     init(): void;
-    setProps(nextProps: DesignerProps): void;
+    setProps(nextProps: Partial<DesignerProps>): void;
     get(key: string): any;
     postEvent(event: string, ...args: any[]): void;
     onEvent(event: string, listener: (...args: any[]) => void): () => void;
     createLocation(locationData: LocationData<Node>): DropLocation;
     clearLocation(): void;
+    createScroller(scrollable: Scrollable): Scroller;
     createOffsetObserver(nodeInstance: NodeSelector): OffsetObserver | null;
     private clearOobxList;
     touchOffsetObserver(): void;
     onInit(listener: (designer: Designer) => void): void;
     get schema(): ProjectSchema<import("..").RootSchema>;
+    get simulatorProps(): Record<string, any>;
+    /**
+     * 提供给模拟器的参数
+     */
+    get projectSimulatorProps(): any;
+    get suspended(): boolean;
+    set suspended(flag: boolean);
     setSchema(schema: ProjectSchema): void;
     transformProps(props: PropsMap, node: Node, stage: TRANSFORM_STAGE): PropsMap;
     addPropsReducer(reducer: PropsTransducer, stage: TRANSFORM_STAGE): void;
     createSettingEntry(nodes: Node[]): SettingTopEntry;
+    purge(): void;
 }

package/dist/designer/dragon.d.ts

@@ -1,14 +1,13 @@
 import type { Designer } from '.';
 import type { Node } from '../document';
 import type { Simulator } from '../simulator';
-import type { NodeSchema } from '../types';
-import type { ComponentInstance } from './component-meta';
+import type { ComponentInstance, NodeSchema } from '../types';
 import type { LocateEvent } from './location';
 import type { Sensor } from './sensor';
 export declare enum DRAGON_EVENT {
-    DRAGSTART = "dragstart",
-    DRAG = "drag",
-    DRAGEND = "dragend"
+    DRAGSTART = "dragon:dragstart",
+    DRAG = "dragon:drag",
+    DRAGEND = "dragon:dragend"
 }
 export declare enum DragObjectType {
     Node = "node",

package/dist/designer/index.d.ts

@@ -1,5 +1,4 @@
 export * from './clipboard';
-export * from './component-meta';
 export * from './designer';
 export * from './detecting';
 export * from './dragon';

package/dist/designer/location.d.ts

@@ -79,9 +79,6 @@ export interface LocateEvent {
 }
 export declare const isLocationData: (obj: any) => obj is LocationData;
 export declare const isLocationChildrenDetail: (obj: any) => obj is LocationChildrenDetail;
-export declare const isText: (elem: any) => elem is Text;
-export declare const isElement: (node: any) => node is Element;
-export declare const isDocumentElem: (elem: any) => elem is Document;
 export declare const getWindow: (elem: Element | Document) => Window;
 export declare class DropLocation {
     readonly target: INode;

package/dist/designer/scroller.d.ts

@@ -0,0 +1,34 @@
+export interface Scrollable {
+    scrollTarget?: ScrollTarget | Element;
+    bounds?: DOMRect | null;
+    scale?: number;
+}
+export declare class ScrollTarget {
+    private target;
+    get left(): number;
+    get top(): number;
+    private doc?;
+    constructor(target: Window | Element);
+    scrollTo(options: {
+        left?: number;
+        top?: number;
+    }): void;
+    scrollToXY(x: number, y: number): void;
+    get scrollHeight(): number;
+    get scrollWidth(): number;
+}
+export declare class Scroller {
+    private pid;
+    scrollable: Scrollable;
+    constructor(scrollable: Scrollable);
+    get scrollTarget(): ScrollTarget | null;
+    scrollTo(options: {
+        left?: number;
+        top?: number;
+    }): void;
+    scrolling(point: {
+        globalX: number;
+        globalY: number;
+    }): void;
+    cancel(): void;
+}

package/dist/designer/selection.d.ts

@@ -1,4 +1,4 @@
-import type { Node } from '../document';
+import { type Node } from '../document';
 import type { Designer } from './designer';
 export declare enum SELECTION_EVENT {
     CHANGE = "selection:change"

package/dist/designer/sensor.d.ts

@@ -1,5 +1,5 @@
 import type { Node } from '../document';
-import type { ComponentInstance } from './component-meta';
+import type { ComponentInstance } from '../types';
 import type { NodeInstance } from './dragon';
 import type { DropLocation, LocateEvent } from './location';
 export interface Sensor<T = Node> {

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

@@ -1,4 +1,4 @@
-import type { Editor, Node, SetterManager } from '../..';
+import type { Editor, Node, Setters } from '../..';
 import type { Designer } from '../designer';
 import type { SettingField } from './setting-field';
 export interface SettingEntry {
@@ -20,7 +20,7 @@ export interface SettingEntry {
      * 编辑器引用
      */
     readonly editor: Editor;
-    readonly setters: SetterManager;
+    readonly setters: Setters;
     /**
      * 取得子项
      */

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

@@ -1,6 +1,6 @@
-import type { DynamicSetter, FieldConfig, FieldExtraProps, SetterType } from '../component-meta';
-import type { SettingTopEntry } from './setting-top-entry';
+import type { DynamicSetter, FieldConfig, FieldExtraProps, SetterType } from '../../types';
 import { SettingPropEntry } from './setting-prop-entry';
+import type { SettingTopEntry } from './setting-top-entry';
 export interface SetValueOptions {
     disableMutator?: boolean;
     type?: PropValueChangedType;

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

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

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

@@ -1,6 +1,6 @@
-import type { ComponentMeta, Designer, FieldExtraProps, Node, PropKey } from '../..';
-import type { Editor } from '../../editor';
-import type { SetterManager } from '../../setter-manager';
+import { type ComponentMeta, type Designer, type FieldExtraProps, type Node, type PropKey } from '../..';
+import type { Setters } from '../../setters';
+import type { Editor } from '../../types';
 import type { SettingEntry } from './setting-entry';
 import type { SetValueOptions, SettingField } from './setting-field';
 import type { SettingTopEntry } from './setting-top-entry';
@@ -10,7 +10,7 @@ export declare class SettingPropEntry implements SettingEntry {
     readonly isSameComponent: boolean;
     readonly isMultiple: boolean;
     readonly isSingle: boolean;
-    readonly setters: SetterManager;
+    readonly setters: Setters;
     readonly nodes: Node[];
     readonly componentMeta: ComponentMeta | null;
     readonly designer: Designer | undefined;

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

@@ -1,4 +1,4 @@
-import type { ComponentMeta, Designer, Editor, Node, PropKey, SetterManager } from '../..';
+import { type ComponentMeta, type Designer, type Editor, type Node, type PropKey, type Setters } from '../..';
 import type { SettingEntry } from './setting-entry';
 import { SettingField } from './setting-field';
 export declare const generateSessionId: (nodes: Node[]) => string;
@@ -31,7 +31,7 @@ export declare class SettingTopEntry implements SettingEntry {
     readonly id: string;
     readonly first: Node;
     readonly designer: Designer | undefined;
-    readonly setters: SetterManager;
+    readonly setters: Setters;
     disposeFunctions: any[];
     constructor(editor: Editor, nodes: Node[]);
     private setupComponentMeta;

package/dist/document/document.d.ts

@@ -1,8 +1,7 @@
-import type { ComponentsMap, Designer, DropLocation } from '../designer';
+import { type Designer, type 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 { type ComponentsMap, type NodeSchema, type RootSchema, TRANSFORM_STAGE } from '../types';
 import { History } from './history';
 import { Node } from './node/node';
 export declare enum DOCUMENT_EVENT {
@@ -87,7 +86,6 @@ export declare class 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;

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

@@ -1,6 +1,5 @@
-import type { NodeSchema } from '../../types';
-import type { Node } from './node';
-import { TRANSFORM_STAGE } from '../../types';
+import { type NodeSchema, TRANSFORM_STAGE } from '../../types';
+import { type Node } from './node';
 export declare enum NODE_CHILDREN_EVENT {
     CHANGE = "nodeChildren:change",
     INSERT = "nodeChildren:insert"

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

@@ -1,8 +1,7 @@
-import type { NodeSchema } from '../../types';
+import { type SettingTopEntry } from '../..';
+import { type NodeSchema, TRANSFORM_STAGE } 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 {

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

@@ -1,7 +1,6 @@
-import type { NodeSchema } from '../../types';
+import { type NodeSchema, TRANSFORM_STAGE } from '../../types';
 import type { Node } from '../node/node';
-import type { Props } from './props';
-import { TRANSFORM_STAGE } from '../../types';
+import { type Props } from './props';
 export declare const UNSET: unique symbol;
 export type UNSET = typeof UNSET;
 export type ValueTypes = 'unset' | 'literal' | 'list' | 'map' | 'expression';

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

@@ -1,7 +1,6 @@
-import type { Node } from '../node/node';
-import type { PropKey, PropValue, PropsMap } from './prop';
 import { TRANSFORM_STAGE } from '../../types';
-import { Prop, UNSET } from './prop';
+import type { Node } from '../node/node';
+import { Prop, type PropKey, type PropValue, type PropsMap, UNSET } from './prop';
 /**
  * prop key convert to extra key
  */

package/dist/engine/editor.d.ts

@@ -0,0 +1,45 @@
+import EventEmitter from 'events';
+import { type EditorConfig, type EditorGetResult, type EditorValueKey, EventBus, type HookConfig, type Editor as IEditor, type Plugins } from '..';
+export declare class Editor extends EventEmitter implements IEditor {
+    private accessor context;
+    config?: EditorConfig;
+    eventBus: EventBus;
+    components?: IEditor['components'];
+    private hooks;
+    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;
+    register(data: any, key?: EditorValueKey): void;
+    init(config?: EditorConfig, components?: Editor['components']): Promise<any>;
+    destroy(): void;
+    extend(pluginManager: Plugins): Promise<void>;
+    initHooks: (hooks: HookConfig[]) => HookConfig[];
+    registerHooks: (hooks: HookConfig[]) => void;
+    unregisterHooks: () => 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;

package/dist/engine/engine.d.ts

@@ -0,0 +1,11 @@
+import { type ConfigOptions, Event, Hotkey, Materials, Plugins, Setters } from '..';
+declare const project: import("..").Project;
+declare const hotkey: Hotkey;
+declare const setters: Setters;
+declare const materials: Materials;
+declare const event: Event;
+declare const logger: import("..").Logger;
+declare let plugins: Plugins;
+export declare const init: (options?: ConfigOptions) => Promise<void>;
+export declare const destroy: () => Promise<void>;
+export { event, hotkey, logger, materials, plugins, project, setters };

package/dist/engine/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TODO: 从 core 中抽离出来
+ */
+export * from './engine';
+export declare const version = "_EASY_EDITOR_VERSION_";