@mdesignable/core 1.0.0-beta.64

package/esm/models/Workspace.d.ts

@@ -0,0 +1,41 @@
+import { Engine } from './Engine';
+import { Viewport } from './Viewport';
+import { Operation, IOperation } from './Operation';
+import { History } from './History';
+import { ICustomEvent, EventContainer } from '@mdesignable/shared';
+import { IEngineContext } from '../types';
+export interface IViewportMatcher {
+    contentWindow?: Window;
+    viewportElement?: HTMLElement;
+}
+export interface IWorkspace {
+    id?: string;
+    title?: string;
+    description?: string;
+    operation: IOperation;
+}
+export interface IWorkspaceProps {
+    id?: string;
+    title?: string;
+    description?: string;
+    contentWindow?: Window;
+    viewportElement?: HTMLElement;
+}
+export declare class Workspace {
+    id: string;
+    title: string;
+    description: string;
+    engine: Engine;
+    viewport: Viewport;
+    outline: Viewport;
+    operation: Operation;
+    history: History<Workspace>;
+    props: IWorkspaceProps;
+    constructor(engine: Engine, props: IWorkspaceProps);
+    getEventContext(): IEngineContext;
+    attachEvents(container: EventContainer, contentWindow: Window): void;
+    detachEvents(container: EventContainer): void;
+    dispatch(event: ICustomEvent): boolean;
+    serialize(): IWorkspace;
+    from(workspace?: IWorkspace): void;
+}

package/esm/models/Workspace.js

@@ -0,0 +1,95 @@
+import { Viewport } from './Viewport';
+import { Operation } from './Operation';
+import { History } from './History';
+import { uid } from '@mdesignable/shared';
+import { HistoryGotoEvent, HistoryRedoEvent, HistoryUndoEvent, HistoryPushEvent, } from '../events';
+//工作区模型
+var Workspace = /** @class */ (function () {
+    function Workspace(engine, props) {
+        var _this = this;
+        this.engine = engine;
+        this.props = props;
+        this.id = props.id || uid();
+        this.title = props.title;
+        this.description = props.description;
+        this.viewport = new Viewport({
+            engine: this.engine,
+            workspace: this,
+            viewportElement: props.viewportElement,
+            contentWindow: props.contentWindow,
+            nodeIdAttrName: this.engine.props.nodeIdAttrName,
+            moveSensitive: true,
+            moveInsertionType: 'all',
+        });
+        this.outline = new Viewport({
+            engine: this.engine,
+            workspace: this,
+            viewportElement: props.viewportElement,
+            contentWindow: props.contentWindow,
+            nodeIdAttrName: this.engine.props.outlineNodeIdAttrName,
+            moveSensitive: false,
+            moveInsertionType: 'block',
+        });
+        this.operation = new Operation(this);
+        this.history = new History(this, {
+            onPush: function (item) {
+                _this.operation.dispatch(new HistoryPushEvent(item));
+            },
+            onRedo: function (item) {
+                _this.operation.hover.clear();
+                _this.operation.dispatch(new HistoryRedoEvent(item));
+            },
+            onUndo: function (item) {
+                _this.operation.hover.clear();
+                _this.operation.dispatch(new HistoryUndoEvent(item));
+            },
+            onGoto: function (item) {
+                _this.operation.hover.clear();
+                _this.operation.dispatch(new HistoryGotoEvent(item));
+            },
+        });
+    }
+    Workspace.prototype.getEventContext = function () {
+        return {
+            workbench: this.engine.workbench,
+            workspace: this,
+            engine: this.engine,
+            viewport: this.viewport,
+        };
+    };
+    Workspace.prototype.attachEvents = function (container, contentWindow) {
+        this.engine.attachEvents(container, contentWindow, this.getEventContext());
+    };
+    Workspace.prototype.detachEvents = function (container) {
+        this.engine.detachEvents(container);
+    };
+    Workspace.prototype.dispatch = function (event) {
+        return this.engine.dispatch(event, this.getEventContext());
+    };
+    Workspace.prototype.serialize = function () {
+        return {
+            id: this.id,
+            title: this.title,
+            description: this.description,
+            operation: this.operation.serialize(),
+        };
+    };
+    Workspace.prototype.from = function (workspace) {
+        if (!workspace)
+            return;
+        if (workspace.operation) {
+            this.operation.from(workspace.operation);
+        }
+        if (workspace.id) {
+            this.id = workspace.id;
+        }
+        if (workspace.title) {
+            this.title = workspace.title;
+        }
+        if (workspace.description) {
+            this.description = workspace.description;
+        }
+    };
+    return Workspace;
+}());
+export { Workspace };

package/esm/models/index.d.ts

@@ -0,0 +1,13 @@
+export * from './Engine';
+export * from './Screen';
+export * from './Cursor';
+export * from './Operation';
+export * from './Viewport';
+export * from './TreeNode';
+export * from './Workbench';
+export * from './Workspace';
+export * from './Selection';
+export * from './MoveHelper';
+export * from './Keyboard';
+export * from './Shortcut';
+export * from './History';

package/esm/models/index.js

@@ -0,0 +1,13 @@
+export * from './Engine';
+export * from './Screen';
+export * from './Cursor';
+export * from './Operation';
+export * from './Viewport';
+export * from './TreeNode';
+export * from './Workbench';
+export * from './Workspace';
+export * from './Selection';
+export * from './MoveHelper';
+export * from './Keyboard';
+export * from './Shortcut';
+export * from './History';

package/esm/presets.d.ts

@@ -0,0 +1,4 @@
+import { DragDropDriver, MouseClickDriver, MouseMoveDriver, ViewportResizeDriver, ViewportScrollDriver, KeyboardDriver } from './drivers';
+export declare const DEFAULT_EFFECTS: ((engine: import("./models").Engine) => void)[];
+export declare const DEFAULT_DRIVERS: (typeof DragDropDriver | typeof MouseClickDriver | typeof MouseMoveDriver | typeof ViewportResizeDriver | typeof ViewportScrollDriver | typeof KeyboardDriver)[];
+export declare const DEFAULT_SHORTCUTS: import("./models").Shortcut[];

package/esm/presets.js

@@ -0,0 +1,38 @@
+import { DragDropDriver, MouseClickDriver, MouseMoveDriver, ViewportResizeDriver, ViewportScrollDriver, KeyboardDriver, } from './drivers';
+import { useCursorEffect, useViewportEffect, useDragDropEffect, useSelectionEffect, useResizeEffect, useKeyboardEffect, useAutoScrollEffect, useWorkspaceEffect, useFreeSelectionEffect, useContentEditableEffect, useTranslateEffect, } from './effects';
+import { SelectNodes, SelectAllNodes, SelectSameTypeNodes, DeleteNodes, CopyNodes, PasteNodes, UndoMutation, RedoMutation, CursorSwitchSelection, PreventCommandX, SelectPrevNode, SelectNextNode, } from './shortcuts';
+export var DEFAULT_EFFECTS = [
+    useFreeSelectionEffect,
+    useCursorEffect,
+    useViewportEffect,
+    useDragDropEffect,
+    useSelectionEffect,
+    useKeyboardEffect,
+    useAutoScrollEffect,
+    useWorkspaceEffect,
+    useContentEditableEffect,
+    useTranslateEffect,
+    useResizeEffect,
+];
+export var DEFAULT_DRIVERS = [
+    MouseMoveDriver,
+    DragDropDriver,
+    MouseClickDriver,
+    ViewportResizeDriver,
+    ViewportScrollDriver,
+    KeyboardDriver,
+];
+export var DEFAULT_SHORTCUTS = [
+    PreventCommandX,
+    SelectNodes,
+    SelectAllNodes,
+    SelectSameTypeNodes,
+    DeleteNodes,
+    CopyNodes,
+    PasteNodes,
+    SelectPrevNode,
+    SelectNextNode,
+    UndoMutation,
+    RedoMutation,
+    CursorSwitchSelection,
+];

package/esm/registry.d.ts

@@ -0,0 +1,16 @@
+import { IDesignerBehaviors, IDesignerLocales, IDesignerIcons, IBehaviorLike, IBehavior } from './types';
+import { TreeNode } from './models';
+declare const DESIGNER_GlobalRegistry: {
+    setDesignerLanguage: (lang: string) => void;
+    setDesignerBehaviors: (behaviors: IBehaviorLike[]) => void;
+    getDesignerBehaviors: (node: TreeNode) => IBehavior[];
+    getDesignerIcon: (name: string) => any;
+    getDesignerLanguage: () => string;
+    getDesignerMessage: (token: string, locales?: IDesignerLocales) => any;
+    registerDesignerIcons: (map: IDesignerIcons) => void;
+    registerDesignerLocales: (...packages: IDesignerLocales[]) => void;
+    registerDesignerBehaviors: (...packages: IDesignerBehaviors[]) => void;
+};
+export type IDesignerRegistry = typeof DESIGNER_GlobalRegistry;
+export declare const GlobalRegistry: IDesignerRegistry;
+export {};

package/esm/registry.js

@@ -0,0 +1,123 @@
+import { each } from '@mdesignable/shared';
+import { Path } from '@formily/path';
+import { observable } from '@formily/reactive';
+import { mergeLocales, lowerSnake, getBrowserLanguage } from './internals';
+import { isBehaviorHost } from './externals';
+import { isBehaviorList } from './externals';
+var getISOCode = function (language) {
+    var isoCode = DESIGNER_LANGUAGE_STORE.value;
+    var lang = lowerSnake(language);
+    if (DESIGNER_LOCALES_STORE.value[lang]) {
+        return lang;
+    }
+    each(DESIGNER_LOCALES_STORE.value, function (_, key) {
+        if (key.indexOf(lang) > -1 || String(lang).indexOf(key) > -1) {
+            isoCode = key;
+            return false;
+        }
+    });
+    return isoCode;
+};
+var reSortBehaviors = function (target, sources) {
+    var findTargetBehavior = function (behavior) { return target.includes(behavior); };
+    var findSourceBehavior = function (name) {
+        for (var key in sources) {
+            var Behavior = sources[key].Behavior;
+            for (var i = 0; i < Behavior.length; i++) {
+                if (Behavior[i].name === name)
+                    return Behavior[i];
+            }
+        }
+    };
+    each(sources, function (item) {
+        if (!item)
+            return;
+        if (!isBehaviorHost(item))
+            return;
+        var Behavior = item.Behavior;
+        each(Behavior, function (behavior) {
+            if (findTargetBehavior(behavior))
+                return;
+            var name = behavior.name;
+            each(behavior.extends, function (dep) {
+                var behavior = findSourceBehavior(dep);
+                if (!behavior)
+                    throw new Error("No ".concat(dep, " behavior that ").concat(name, " depends on"));
+                if (!findTargetBehavior(behavior)) {
+                    target.unshift(behavior);
+                }
+            });
+            target.push(behavior);
+        });
+    });
+};
+var DESIGNER_BEHAVIORS_STORE = observable.ref([]);
+var DESIGNER_ICONS_STORE = observable.ref({});
+var DESIGNER_LOCALES_STORE = observable.ref({});
+var DESIGNER_LANGUAGE_STORE = observable.ref(getBrowserLanguage());
+var DESIGNER_GlobalRegistry = {
+    setDesignerLanguage: function (lang) {
+        DESIGNER_LANGUAGE_STORE.value = lang;
+    },
+    setDesignerBehaviors: function (behaviors) {
+        DESIGNER_BEHAVIORS_STORE.value = behaviors.reduce(function (buf, behavior) {
+            if (isBehaviorHost(behavior)) {
+                return buf.concat(behavior.Behavior);
+            }
+            else if (isBehaviorList(behavior)) {
+                return buf.concat(behavior);
+            }
+            return buf;
+        }, []);
+    },
+    getDesignerBehaviors: function (node) {
+        return DESIGNER_BEHAVIORS_STORE.value.filter(function (pattern) {
+            return pattern.selector(node);
+        });
+    },
+    getDesignerIcon: function (name) {
+        return DESIGNER_ICONS_STORE[name];
+    },
+    getDesignerLanguage: function () {
+        return getISOCode(DESIGNER_LANGUAGE_STORE.value);
+    },
+    getDesignerMessage: function (token, locales) {
+        var lang = getISOCode(DESIGNER_LANGUAGE_STORE.value);
+        var locale = locales ? locales[lang] : DESIGNER_LOCALES_STORE.value[lang];
+        if (!locale) {
+            for (var key in DESIGNER_LOCALES_STORE.value) {
+                var message = Path.getIn(DESIGNER_LOCALES_STORE.value[key], lowerSnake(token));
+                if (message)
+                    return message;
+            }
+            return;
+        }
+        return Path.getIn(locale, lowerSnake(token));
+    },
+    registerDesignerIcons: function (map) {
+        Object.assign(DESIGNER_ICONS_STORE, map);
+    },
+    registerDesignerLocales: function () {
+        var packages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            packages[_i] = arguments[_i];
+        }
+        packages.forEach(function (locales) {
+            mergeLocales(DESIGNER_LOCALES_STORE.value, locales);
+        });
+    },
+    registerDesignerBehaviors: function () {
+        var packages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            packages[_i] = arguments[_i];
+        }
+        var results = [];
+        packages.forEach(function (sources) {
+            reSortBehaviors(results, sources);
+        });
+        if (results.length) {
+            DESIGNER_BEHAVIORS_STORE.value = results;
+        }
+    },
+};
+export var GlobalRegistry = DESIGNER_GlobalRegistry;

package/esm/shortcuts/CursorSwitch.d.ts

@@ -0,0 +1,2 @@
+import { Shortcut } from '../models';
+export declare const CursorSwitchSelection: Shortcut;

package/esm/shortcuts/CursorSwitch.js

@@ -0,0 +1,10 @@
+import { CursorType, KeyCode, Shortcut } from '../models';
+export var CursorSwitchSelection = new Shortcut({
+    codes: [KeyCode.Shift, KeyCode.S],
+    handler: function (context) {
+        var engine = context === null || context === void 0 ? void 0 : context.engine;
+        if (engine) {
+            engine.cursor.setType(CursorType.Selection);
+        }
+    },
+});

package/esm/shortcuts/MultiSelection.d.ts

@@ -0,0 +1,5 @@
+import { Shortcut } from '../models';
+export declare const SelectNodes: Shortcut;
+export declare const SelectSameTypeNodes: Shortcut;
+export declare const PreventCommandX: Shortcut;
+export declare const SelectAllNodes: Shortcut;

package/esm/shortcuts/MultiSelection.js

@@ -0,0 +1,27 @@
+import { KeyCode, Shortcut } from '../models';
+export var SelectNodes = new Shortcut({
+    codes: [[KeyCode.Meta], [KeyCode.Control]],
+});
+export var SelectSameTypeNodes = new Shortcut({
+    codes: [KeyCode.Shift],
+});
+export var PreventCommandX = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.X],
+        [KeyCode.Control, KeyCode.X],
+    ],
+});
+export var SelectAllNodes = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.A],
+        [KeyCode.Control, KeyCode.A],
+    ],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            var tree = operation.tree;
+            var selection = operation.selection;
+            selection.batchSelect(tree.descendants);
+        }
+    },
+});

package/esm/shortcuts/NodeMutation.d.ts

@@ -0,0 +1,7 @@
+import { Shortcut } from '../models';
+/**
+ * 快捷删除，快捷复制粘贴
+ */
+export declare const DeleteNodes: Shortcut;
+export declare const CopyNodes: Shortcut;
+export declare const PasteNodes: Shortcut;

package/esm/shortcuts/NodeMutation.js

@@ -0,0 +1,40 @@
+import { KeyCode, Shortcut, TreeNode } from '../models';
+/**
+ * 快捷删除，快捷复制粘贴
+ */
+export var DeleteNodes = new Shortcut({
+    codes: [[KeyCode.Backspace], [KeyCode.Delete]],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            TreeNode.remove(operation.selection.selectedNodes);
+        }
+    },
+});
+var Clipboard = {
+    nodes: [],
+};
+export var CopyNodes = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.C],
+        [KeyCode.Control, KeyCode.C],
+    ],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            Clipboard.nodes = operation.selection.selectedNodes;
+        }
+    },
+});
+export var PasteNodes = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.V],
+        [KeyCode.Control, KeyCode.V],
+    ],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            TreeNode.clone(Clipboard.nodes);
+        }
+    },
+});

package/esm/shortcuts/QuickSelection.d.ts

@@ -0,0 +1,3 @@
+import { Shortcut } from '../models';
+export declare const SelectPrevNode: Shortcut;
+export declare const SelectNextNode: Shortcut;

package/esm/shortcuts/QuickSelection.js

@@ -0,0 +1,85 @@
+import { KeyCode, Shortcut } from '../models';
+var findBottomLastChild = function (node) {
+    if (!node)
+        return node;
+    if (node.lastChild) {
+        return findBottomLastChild(node.lastChild);
+    }
+    return node;
+};
+var findTopParentNext = function (node) {
+    var _a;
+    if (!node.parent)
+        return node;
+    if ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.next)
+        return node.parent.next;
+    return findTopParentNext(node.parent);
+};
+export var SelectPrevNode = new Shortcut({
+    codes: [
+        [KeyCode.Up],
+        [KeyCode.PageUp],
+        [KeyCode.ArrowUp],
+        [KeyCode.Left],
+        [KeyCode.LeftWindowKey],
+        [KeyCode.ArrowLeft],
+    ],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            var tree = operation.tree;
+            var selection = operation.selection;
+            var selectedNode = tree.findById(selection.last);
+            if (selectedNode) {
+                var previousNode = selectedNode.previous;
+                if (previousNode) {
+                    var bottom = findBottomLastChild(previousNode);
+                    if (bottom) {
+                        selection.select(bottom);
+                    }
+                    else {
+                        selection.select(previousNode);
+                    }
+                }
+                else if (selectedNode.parent) {
+                    selection.select(selectedNode.parent);
+                }
+                else {
+                    var bottom = findBottomLastChild(selectedNode.lastChild);
+                    if (bottom) {
+                        selection.select(bottom);
+                    }
+                }
+            }
+        }
+    },
+});
+export var SelectNextNode = new Shortcut({
+    codes: [
+        [KeyCode.Down],
+        [KeyCode.PageDown],
+        [KeyCode.ArrowDown],
+        [KeyCode.Right],
+        [KeyCode.RightWindowKey],
+        [KeyCode.ArrowRight],
+    ],
+    handler: function (context) {
+        var operation = context === null || context === void 0 ? void 0 : context.workspace.operation;
+        if (operation) {
+            var tree = operation.tree;
+            var selection = operation.selection;
+            var selectedNode = tree.findById(selection.last);
+            if (selectedNode) {
+                var nextNode = selectedNode.firstChild
+                    ? selectedNode.firstChild
+                    : selectedNode.next;
+                if (nextNode) {
+                    selection.select(nextNode);
+                }
+                else {
+                    selection.select(findTopParentNext(selectedNode));
+                }
+            }
+        }
+    },
+});

package/esm/shortcuts/UndoRedo.d.ts

@@ -0,0 +1,3 @@
+import { Shortcut } from '../models';
+export declare const UndoMutation: Shortcut;
+export declare const RedoMutation: Shortcut;

package/esm/shortcuts/UndoRedo.js

@@ -0,0 +1,27 @@
+import { KeyCode, Shortcut } from '../models';
+export var UndoMutation = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.Z],
+        [KeyCode.Control, KeyCode.Z],
+    ],
+    handler: function (context) {
+        var workspace = context === null || context === void 0 ? void 0 : context.workspace;
+        if (workspace) {
+            workspace.history.undo();
+        }
+        workspace.operation.hover.clear();
+    },
+});
+export var RedoMutation = new Shortcut({
+    codes: [
+        [KeyCode.Meta, KeyCode.Shift, KeyCode.Z],
+        [KeyCode.Control, KeyCode.Shift, KeyCode.Z],
+    ],
+    handler: function (context) {
+        var workspace = context === null || context === void 0 ? void 0 : context.workspace;
+        if (workspace) {
+            workspace.history.redo();
+        }
+        workspace.operation.hover.clear();
+    },
+});

package/esm/shortcuts/index.d.ts

@@ -0,0 +1,5 @@
+export * from './MultiSelection';
+export * from './NodeMutation';
+export * from './UndoRedo';
+export * from './CursorSwitch';
+export * from './QuickSelection';

package/esm/shortcuts/index.js

@@ -0,0 +1,5 @@
+export * from './MultiSelection';
+export * from './NodeMutation';
+export * from './UndoRedo';
+export * from './CursorSwitch';
+export * from './QuickSelection';