chore: up

packages/designer/src/document/node/node-children.ts

@@ -328,7 +328,7 @@ export class NodeChildren {
     return this.children.filter(fn);
   }
 
-  find(fn: (item: Node, index: number) => Node) {
+  find(fn: (item: Node, index: number) => boolean) {
     return this.children.find(fn);
   }
 

packages/shell/src/node-children.ts

@@ -0,0 +1,92 @@
+import {
+  NodeChildren as InnerNodeChildren,
+  Node as InnerNode,
+} from '@ali/lowcode-designer';
+import { NodeSchema } from '@ali/lowcode-types';
+import Node from './node';
+import { nodeSymbol, nodeChildrenSymbol } from './symbols';
+
+export default class NodeChildren {
+  private readonly [nodeChildrenSymbol]: InnerNodeChildren;
+
+  constructor(nodeChildren: InnerNodeChildren) {
+    this[nodeChildrenSymbol] = nodeChildren;
+  }
+
+  static create(nodeChldren: InnerNodeChildren | null) {
+    if (!nodeChldren) return null;
+    return new NodeChildren(nodeChldren);
+  }
+
+  get size() {
+    return this[nodeChildrenSymbol].size;
+  }
+
+  isEmpty() {
+    return this[nodeChildrenSymbol].isEmpty();
+  }
+
+  delete(node: Node) {
+    return this[nodeChildrenSymbol].delete(node[nodeSymbol]);
+  }
+
+  insert(node: Node, at?: number | null | undefined, useMutator?: boolean) {
+    return this[nodeChildrenSymbol].insert(node[nodeSymbol], at, useMutator);
+  }
+
+  indexOf(node: Node) {
+    return this[nodeChildrenSymbol].indexOf(node[nodeSymbol]);
+  }
+
+  splice(start: number, deleteCount: number, node?: Node) {
+    this[nodeChildrenSymbol].splice(start, deleteCount, node?.[nodeSymbol]);
+  }
+
+  get(index: number) {
+    return this[nodeChildrenSymbol].get(index);
+  }
+
+  has(node: Node) {
+    return this[nodeChildrenSymbol].has(node[nodeSymbol]);
+  }
+
+  forEach(fn: (node: Node, index: number) => void) {
+    this[nodeChildrenSymbol].forEach((item: InnerNode<NodeSchema>, index: number) => {
+      fn(Node.create(item)!, index);
+    });
+  }
+
+  map<T>(fn: (node: Node, index: number) => T[]) {
+    return this[nodeChildrenSymbol].map((item: InnerNode<NodeSchema>, index: number) => {
+      return fn(Node.create(item)!, index);
+    });
+  }
+
+  every(fn: (node: Node, index: number) => boolean) {
+    return this[nodeChildrenSymbol].every((item: InnerNode<NodeSchema>, index: number) => {
+      return fn(Node.create(item)!, index);
+    });
+  }
+
+  some(fn: (node: Node, index: number) => boolean) {
+    return this[nodeChildrenSymbol].some((item: InnerNode<NodeSchema>, index: number) => {
+      return fn(Node.create(item)!, index);
+    });
+  }
+
+  filter(fn: (node: Node, index: number) => boolean) {
+    return this[nodeChildrenSymbol]
+      .filter((item: InnerNode<NodeSchema>, index: number) => {
+        return fn(Node.create(item)!, index);
+      })
+      .map((item: InnerNode<NodeSchema>) => Node.create(item)!);
+  }
+
+  find(fn: (node: Node, index: number) => boolean) {
+    return Node.create(
+      this[nodeChildrenSymbol].find((item: InnerNode<NodeSchema>, index: number) => {
+        return fn(Node.create(item)!, index);
+      }),
+    );
+  }
+}

packages/shell/src/node.ts

@@ -6,6 +6,7 @@ import {
 import { CompositeValue, NodeSchema, TransformStage } from '@ali/lowcode-types';
 import Prop from './prop';
 import DocumentModel from './document-model';
+import NodeChildren from './node-children';
 import { documentSymbol, nodeSymbol } from './symbols';
 
 export default class Node {
@@ -17,11 +18,19 @@ export default class Node {
     this[documentSymbol] = node.document;
   }
 
-  static create(node: InnerNode | null) {
+  static create(node: InnerNode | null | undefined) {
     if (!node) return null;
     return new Node(node);
   }
 
+  get id() {
+    return this[nodeSymbol].id;
+  }
+
+  get componentName() {
+    return this[nodeSymbol].componentName;
+  }
+
   getDocumentModel() {
     return DocumentModel.create(this[documentSymbol]);
   }
@@ -51,18 +60,18 @@ export default class Node {
   }
 
   getPrevSibling() {
-    return this[nodeSymbol].prevSibling;
+    return Node.create(this[nodeSymbol].prevSibling);
   }
   getNextSibling() {
-    return this[nodeSymbol].nextSibling;
+    return Node.create(this[nodeSymbol].nextSibling);
   }
 
   getParent() {
-    return this[nodeSymbol].parent;
+    return Node.create(this[nodeSymbol].parent);
   }
 
   getChildren() {
-    return this[nodeSymbol].children;
+    return NodeChildren.create(this[nodeSymbol].children);
   }
 
   importSchema(data: NodeSchema) {

packages/shell/src/prop.ts

@@ -15,6 +15,14 @@ export default class Prop {
     return new Prop(prop);
   }
 
+  getId() {
+    return this[propSymbol].id;
+  }
+
+  getKey() {
+    return this[propSymbol].key;
+  }
+
   getNode() {
     return Node.create(this[propSymbol].getNode());
   }

packages/shell/src/symbols.ts

@@ -7,6 +7,7 @@ export const skeletonSymbol = Symbol('skeleton');
 export const documentSymbol = Symbol('document');
 export const editorSymbol = Symbol('editor');
 export const nodeSymbol = Symbol('node');
+export const nodeChildrenSymbol = Symbol('nodeChildren');
 export const propsSymbol = Symbol('props');
 export const propSymbol = Symbol('prop');
 export const detectingSymbol = Symbol('detecting');