@thienvu18/designable-core 2.0.0 → 2.0.2

package/esm/models/Selection.js

@@ -1,155 +1,149 @@
-import { observable, define, action } from '@formily/reactive';
-import { SelectNodeEvent, UnSelectNodeEvent } from '../events';
-import { isStr, isArr } from '@thienvu18/designable-shared';
+import { action, define, observable } from '@formily/reactive'
+import { isArr, isStr } from '@thienvu18/designable-shared'
+import { SelectNodeEvent, UnSelectNodeEvent } from '../events'
 export class Selection {
-    constructor(props) {
-        this.selected = [];
-        this.indexes = {};
-        if (props.selected) {
-            this.selected = props.selected;
+  constructor(props) {
+    this.selected = []
+    this.indexes = {}
+    if (props.selected) {
+      this.selected = props.selected
+    }
+    if (props.operation) {
+      this.operation = props.operation
+    }
+    this.makeObservable()
+  }
+  makeObservable() {
+    define(this, {
+      selected: observable,
+      select: action,
+      batchSelect: action,
+      add: action,
+      remove: action,
+      clear: action,
+      crossAddTo: action,
+    })
+  }
+  trigger(type = SelectNodeEvent) {
+    return this.operation.dispatch(
+      new type({
+        target: this.operation.tree,
+        source: this.selectedNodes,
+      })
+    )
+  }
+  select(id) {
+    if (isStr(id)) {
+      if (this.selected.length === 1 && this.selected.includes(id)) {
+        this.trigger(SelectNodeEvent)
+        return
+      }
+      this.selected = [id]
+      this.indexes = { [id]: true }
+      this.trigger(SelectNodeEvent)
+    } else {
+      this.select(id?.id)
+    }
+  }
+  safeSelect(id) {
+    if (!id) return
+    this.select(id)
+  }
+  mapIds(ids) {
+    return isArr(ids) ? ids.map((node) => (isStr(node) ? node : node?.id)) : []
+  }
+  batchSelect(ids) {
+    this.selected = this.mapIds(ids)
+    this.indexes = this.selected.reduce((buf, id) => {
+      buf[id] = true
+      return buf
+    }, {})
+    this.trigger(SelectNodeEvent)
+  }
+  batchSafeSelect(ids) {
+    if (!ids?.length) return
+    this.batchSelect(ids)
+  }
+  get selectedNodes() {
+    return this.selected.map((id) => this.operation.tree.findById(id))
+  }
+  get first() {
+    if (this.selected && this.selected.length) return this.selected[0]
+  }
+  get last() {
+    if (this.selected && this.selected.length)
+      return this.selected[this.selected.length - 1]
+  }
+  get length() {
+    return this.selected.length
+  }
+  add(...ids) {
+    this.mapIds(ids).forEach((id) => {
+      if (isStr(id)) {
+        if (!this.selected.includes(id)) {
+          this.selected.push(id)
+          this.indexes[id] = true
         }
-        if (props.operation) {
-            this.operation = props.operation;
-        }
-        this.makeObservable();
-    }
-    makeObservable() {
-        define(this, {
-            selected: observable,
-            select: action,
-            batchSelect: action,
-            add: action,
-            remove: action,
-            clear: action,
-            crossAddTo: action,
-        });
-    }
-    trigger(type = SelectNodeEvent) {
-        return this.operation.dispatch(new type({
-            target: this.operation.tree,
-            source: this.selectedNodes,
-        }));
-    }
-    select(id) {
-        if (isStr(id)) {
-            if (this.selected.length === 1 && this.selected.includes(id)) {
-                this.trigger(SelectNodeEvent);
-                return;
+      } else {
+        this.add(id?.id)
+      }
+    })
+    this.trigger()
+  }
+  crossAddTo(node) {
+    if (node.parent) {
+      const selectedNodes = this.selectedNodes
+      if (this.has(node)) {
+        this.remove(node)
+      } else {
+        const minDistanceNode = selectedNodes.reduce(
+          (minDistanceNode, item) => {
+            return item.distanceTo(node) < minDistanceNode.distanceTo(node)
+              ? item
+              : minDistanceNode
+          },
+          selectedNodes[0]
+        )
+        if (minDistanceNode) {
+          const crossNodes = node.crossSiblings(minDistanceNode)
+          crossNodes.forEach((node) => {
+            if (!this.has(node.id)) {
+              this.selected.push(node.id)
+              this.indexes[node.id] = true
             }
-            this.selected = [id];
-            this.indexes = { [id]: true };
-            this.trigger(SelectNodeEvent);
+          })
         }
-        else {
-            this.select(id?.id);
+        if (!this.has(node.id)) {
+          this.selected.push(node.id)
+          this.indexes[node.id] = true
         }
-    }
-    safeSelect(id) {
-        if (!id)
-            return;
-        this.select(id);
-    }
-    mapIds(ids) {
-        return isArr(ids)
-            ? ids.map((node) => (isStr(node) ? node : node?.id))
-            : [];
-    }
-    batchSelect(ids) {
-        this.selected = this.mapIds(ids);
-        this.indexes = this.selected.reduce((buf, id) => {
-            buf[id] = true;
-            return buf;
-        }, {});
-        this.trigger(SelectNodeEvent);
-    }
-    batchSafeSelect(ids) {
-        if (!ids?.length)
-            return;
-        this.batchSelect(ids);
-    }
-    get selectedNodes() {
-        return this.selected.map((id) => this.operation.tree.findById(id));
-    }
-    get first() {
-        if (this.selected && this.selected.length)
-            return this.selected[0];
-    }
-    get last() {
-        if (this.selected && this.selected.length)
-            return this.selected[this.selected.length - 1];
-    }
-    get length() {
-        return this.selected.length;
-    }
-    add(...ids) {
-        this.mapIds(ids).forEach((id) => {
-            if (isStr(id)) {
-                if (!this.selected.includes(id)) {
-                    this.selected.push(id);
-                    this.indexes[id] = true;
-                }
-            }
-            else {
-                this.add(id?.id);
-            }
-        });
-        this.trigger();
-    }
-    crossAddTo(node) {
-        if (node.parent) {
-            const selectedNodes = this.selectedNodes;
-            if (this.has(node)) {
-                this.remove(node);
-            }
-            else {
-                const minDistanceNode = selectedNodes.reduce((minDistanceNode, item) => {
-                    return item.distanceTo(node) < minDistanceNode.distanceTo(node)
-                        ? item
-                        : minDistanceNode;
-                }, selectedNodes[0]);
-                if (minDistanceNode) {
-                    const crossNodes = node.crossSiblings(minDistanceNode);
-                    crossNodes.forEach((node) => {
-                        if (!this.has(node.id)) {
-                            this.selected.push(node.id);
-                            this.indexes[node.id] = true;
-                        }
-                    });
-                }
-                if (!this.has(node.id)) {
-                    this.selected.push(node.id);
-                    this.indexes[node.id] = true;
-                }
-            }
-        }
-    }
-    remove(...ids) {
-        this.mapIds(ids).forEach((id) => {
-            if (isStr(id)) {
-                this.selected = this.selected.filter((item) => item !== id);
-                delete this.indexes[id];
-            }
-            else {
-                this.remove(id?.id);
-            }
-        });
-        this.trigger(UnSelectNodeEvent);
-    }
-    has(...ids) {
-        return this.mapIds(ids).some((id) => {
-            if (isStr(id)) {
-                return this.indexes[id];
-            }
-            else {
-                if (!id?.id)
-                    return false;
-                return this.has(id?.id);
-            }
-        });
-    }
-    clear() {
-        this.selected = [];
-        this.indexes = {};
-        this.trigger(UnSelectNodeEvent);
-    }
+      }
+    }
+  }
+  remove(...ids) {
+    this.mapIds(ids).forEach((id) => {
+      if (isStr(id)) {
+        this.selected = this.selected.filter((item) => item !== id)
+        delete this.indexes[id]
+      } else {
+        this.remove(id?.id)
+      }
+    })
+    this.trigger(UnSelectNodeEvent)
+  }
+  has(...ids) {
+    return this.mapIds(ids).some((id) => {
+      if (isStr(id)) {
+        return this.indexes[id]
+      } else {
+        if (!id?.id) return false
+        return this.has(id?.id)
+      }
+    })
+  }
+  clear() {
+    this.selected = []
+    this.indexes = {}
+    this.trigger(UnSelectNodeEvent)
+  }
 }

package/esm/models/Shortcut.d.ts

@@ -1,20 +1,20 @@
-import { KeyCode } from '@thienvu18/designable-shared';
-import { IEngineContext } from '../types';
-export { KeyCode };
+import { KeyCode } from '@thienvu18/designable-shared'
+import { IEngineContext } from '../types'
+export { KeyCode }
 export interface IShortcutProps {
-    codes?: KeyCode[] | KeyCode[][];
-    matcher?: (codes: KeyCode[]) => boolean;
-    handler?: (context: IEngineContext) => void;
+  codes?: KeyCode[] | KeyCode[][]
+  matcher?: (codes: KeyCode[]) => boolean
+  handler?: (context: IEngineContext) => void
 }
 export declare class Shortcut {
-    codes: KeyCode[][];
-    handler: (context: IEngineContext) => void;
-    matcher: (codes: KeyCode[]) => boolean;
-    constructor(props: IShortcutProps);
-    parseCodes(codes: Array<KeyCode | KeyCode[]>): KeyCode[][];
-    preventCodes(codes: KeyCode[]): boolean;
-    matched(matched: boolean, context: IEngineContext): boolean;
-    match(codes: KeyCode[], context: IEngineContext): boolean;
-    static matchCode: (code1: KeyCode, code2: KeyCode) => boolean;
-    static sortCodes: (codes: KeyCode[]) => KeyCode[];
+  codes: KeyCode[][]
+  handler: (context: IEngineContext) => void
+  matcher: (codes: KeyCode[]) => boolean
+  constructor(props: IShortcutProps)
+  parseCodes(codes: Array<KeyCode | KeyCode[]>): KeyCode[][]
+  preventCodes(codes: KeyCode[]): boolean
+  matched(matched: boolean, context: IEngineContext): boolean
+  match(codes: KeyCode[], context: IEngineContext): boolean
+  static matchCode: (code1: KeyCode, code2: KeyCode) => boolean
+  static sortCodes: (codes: KeyCode[]) => KeyCode[]
 }

package/esm/models/Shortcut.js

@@ -1,64 +1,63 @@
-import { isFn, KeyCode } from '@thienvu18/designable-shared';
-export { KeyCode };
+import { isFn, KeyCode } from '@thienvu18/designable-shared'
+export { KeyCode }
 export class Shortcut {
-    constructor(props) {
-        this.codes = this.parseCodes(props.codes);
-        this.handler = props.handler;
-        this.matcher = props.matcher;
-    }
-    parseCodes(codes) {
-        const results = [];
-        codes.forEach((code) => {
-            if (Array.isArray(code)) {
-                results.push(code);
-            }
-            else {
-                results.push([code]);
-            }
-        });
-        return results;
-    }
-    preventCodes(codes) {
-        if (this.codes.length) {
-            for (let i = 0; i < codes.length; i++) {
-                const sequence = this.codes[i] ?? [];
-                for (let j = 0; j < sequence.length; j++) {
-                    if (!Shortcut.matchCode(codes[j], sequence[j])) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-    matched(matched, context) {
-        if (isFn(this.handler) && matched) {
-            this.handler(context);
+  constructor(props) {
+    this.codes = this.parseCodes(props.codes)
+    this.handler = props.handler
+    this.matcher = props.matcher
+  }
+  parseCodes(codes) {
+    const results = []
+    codes.forEach((code) => {
+      if (Array.isArray(code)) {
+        results.push(code)
+      } else {
+        results.push([code])
+      }
+    })
+    return results
+  }
+  preventCodes(codes) {
+    if (this.codes.length) {
+      for (let i = 0; i < codes.length; i++) {
+        const sequence = this.codes[i] ?? []
+        for (let j = 0; j < sequence.length; j++) {
+          if (!Shortcut.matchCode(codes[j], sequence[j])) {
+            return false
+          }
         }
-        return matched;
+      }
+      return true
     }
-    match(codes, context) {
-        return this.codes.some((sequence) => {
-            const sortedSelf = Shortcut.sortCodes(sequence);
-            const sortedTarget = Shortcut.sortCodes(codes);
-            if (isFn(this.matcher)) {
-                return this.matched(this.matcher(sortedTarget), context);
-            }
-            if (sortedTarget.length !== sortedSelf.length)
-                return this.matched(false, context);
-            for (let i = 0; i < sortedSelf.length; i++) {
-                if (!Shortcut.matchCode(sortedTarget[i], sortedSelf[i])) {
-                    return this.matched(false, context);
-                }
-            }
-            return this.matched(true, context);
-        });
+    return false
+  }
+  matched(matched, context) {
+    if (isFn(this.handler) && matched) {
+      this.handler(context)
     }
+    return matched
+  }
+  match(codes, context) {
+    return this.codes.some((sequence) => {
+      const sortedSelf = Shortcut.sortCodes(sequence)
+      const sortedTarget = Shortcut.sortCodes(codes)
+      if (isFn(this.matcher)) {
+        return this.matched(this.matcher(sortedTarget), context)
+      }
+      if (sortedTarget.length !== sortedSelf.length)
+        return this.matched(false, context)
+      for (let i = 0; i < sortedSelf.length; i++) {
+        if (!Shortcut.matchCode(sortedTarget[i], sortedSelf[i])) {
+          return this.matched(false, context)
+        }
+      }
+      return this.matched(true, context)
+    })
+  }
 }
 Shortcut.matchCode = (code1, code2) => {
-    return code1?.toLocaleLowerCase?.() === code2?.toLocaleLowerCase?.();
-};
+  return code1?.toLocaleLowerCase?.() === code2?.toLocaleLowerCase?.()
+}
 Shortcut.sortCodes = (codes) => {
-    return codes.map((code) => code.toLocaleLowerCase()).sort();
-};
+  return codes.map((code) => code.toLocaleLowerCase()).sort()
+}

package/esm/models/SnapLine.d.ts

@@ -1,27 +1,27 @@
-import { ILineSegment, IPoint, Rect } from '@thienvu18/designable-shared';
-import { TreeNode } from './TreeNode';
-import { TransformHelper } from './TransformHelper';
-export type ISnapLineType = 'ruler' | 'space-block' | 'normal';
+import { ILineSegment, IPoint, Rect } from '@thienvu18/designable-shared'
+import { TransformHelper } from './TransformHelper'
+import { TreeNode } from './TreeNode'
+export type ISnapLineType = 'ruler' | 'space-block' | 'normal'
 export type ISnapLine = ILineSegment & {
-    type?: ISnapLineType;
-    distance?: number;
-    id?: string;
-    refer?: TreeNode;
-};
+  type?: ISnapLineType
+  distance?: number
+  id?: string
+  refer?: TreeNode
+}
 export declare class SnapLine {
-    _id: string;
-    type: ISnapLineType;
-    distance: number;
-    refer: TreeNode;
-    start: IPoint;
-    end: IPoint;
-    helper: TransformHelper;
-    constructor(helper: TransformHelper, line: ISnapLine);
-    get id(): string;
-    get direction(): "v" | "h";
-    get closest(): boolean;
-    get rect(): Rect;
-    translate(node: TreeNode, translate: IPoint): void;
-    resize(node: TreeNode, rect: Rect): void;
-    snapEdge(rect: Rect): "ht" | "hc" | "hb" | "vl" | "vc" | "vr";
+  _id: string
+  type: ISnapLineType
+  distance: number
+  refer: TreeNode
+  start: IPoint
+  end: IPoint
+  helper: TransformHelper
+  constructor(helper: TransformHelper, line: ISnapLine)
+  get id(): string
+  get direction(): 'v' | 'h'
+  get closest(): boolean
+  get rect(): Rect
+  translate(node: TreeNode, translate: IPoint): void
+  resize(node: TreeNode, rect: Rect): void
+  snapEdge(rect: Rect): 'ht' | 'hc' | 'hb' | 'vl' | 'vc' | 'vr'
 }