@vope/utils 1.4.19 → 1.4.20

package/cjs/index.js

@@ -25,6 +25,7 @@ __export(src_exports, {
   MemoryList: () => MemoryList,
   MemoryPower: () => MemoryPower,
   MemorySimple: () => MemorySimple,
+  Neo4j: () => Neo4j,
   Subscriber: () => Subscriber,
   Union: () => Union,
   clamp: () => clamp,
@@ -590,6 +591,149 @@ var MemorySimple = class {
   }
 };
 
+// src/neo4j.ts
+var Neo4j = class {
+  #nid;
+  #sourceKey;
+  #targetKey;
+  #nodes;
+  #edges;
+  #sources;
+  #targets;
+  #dirs;
+  /**
+   * 点视图
+   */
+  nodes;
+  /**
+   * 边视图
+   */
+  edges;
+  /**
+   * (边)出点视图
+   */
+  sources;
+  /**
+   * (边)入点视图
+   */
+  targets;
+  /**
+   * (边)方向视图
+   */
+  dirs;
+  constructor(nodeList, edgeList, {
+    nid,
+    eid,
+    sourceKey,
+    targetKey,
+    dir
+  }) {
+    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
+    shield(this, "edges", this.#edges = new MemorySimple(eid));
+    shield(this, "sources", this.#sources = new MemoryList(this.#sourceKey = sourceKey));
+    shield(this, "targets", this.#targets = new MemoryList(this.#targetKey = targetKey));
+    shield(this, "dirs", this.#dirs = new MemoryList(dir));
+    nodeList.forEach((node) => this.node("add", node));
+    edgeList.forEach((edge) => this.edge("add", edge));
+  }
+  node(type, value) {
+    const nodes = this.#nodes;
+    if (type === "add") {
+      nodes.push(value);
+    } else if (type === "delete") {
+      const node = nodes.get(value);
+      if (!node)
+        return [];
+      nodes.delete(node);
+      const id = node[this.#nid];
+      const sourceKey = this.#sourceKey;
+      const targetKey = this.#targetKey;
+      const edges = this.#edges;
+      const sources = this.#sources;
+      const targets = this.#targets;
+      const dirs = this.#dirs;
+      const list = [];
+      sources.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        targets.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && sources.deleteType(id);
+      targets.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        sources.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && targets.deleteType(id);
+      return list;
+    }
+  }
+  edge(type, value) {
+    const sourceKey = this.#sourceKey;
+    const targetKey = this.#targetKey;
+    const edges = this.#edges;
+    const sources = this.#sources;
+    const targets = this.#targets;
+    const dirs = this.#dirs;
+    if (type === "add") {
+      const edge = value;
+      edges.push(edge);
+      sources.push(edge);
+      targets.push(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.push(edge);
+    } else if (type === "delete") {
+      const edge = edges.get(value);
+      if (!edge)
+        return false;
+      edges.delete(edge);
+      sources.delete(edge);
+      targets.delete(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+      return true;
+    }
+  }
+  /**
+   * 清理图管理数据
+   */
+  clear() {
+    this.#nodes.clear();
+    this.#edges.clear();
+    this.#sources.clear();
+    this.#targets.clear();
+    this.#dirs.clear();
+  }
+};
+var shield_keys = hash8strings([
+  "push",
+  "delete",
+  "deleteType",
+  "clear"
+]);
+var shield = (obj, key, origin) => {
+  const proxy = new Proxy({}, {
+    get(target, p) {
+      if (p in shield_keys)
+        return;
+      const value = origin[p];
+      if (typeof value === "function") {
+        return function(...args) {
+          const result = origin[p](...args);
+          return result === origin ? proxy : result;
+        };
+      } else {
+        return value;
+      }
+    }
+  });
+  Object.defineProperty(obj, key, {
+    get() {
+      return proxy;
+    }
+  });
+};
+
 // src/once.ts
 var once = (func, thisArg) => {
   let local;

package/lib/index.js

@@ -17,13 +17,14 @@ import { MemoryBasic } from "./memory/basic";
 import { MemoryList } from "./memory/list";
 import { MemoryPower } from "./memory/power";
 import { MemorySimple } from "./memory/simple";
+import { default as default2 } from "./neo4j";
 import { once } from "./once";
 import { parseNum } from "./parse/num";
 import { deconPowersSum } from "./power/decon";
 import { rotateAngle } from "./rotate/angle";
 import { rotateRad } from "./rotate/rad";
 import { css } from "./style/css";
-import { default as default2 } from "./subscriber";
+import { default as default3 } from "./subscriber";
 import { FlexTable } from "./table/flex";
 import { Union } from "./union";
 import { joinPaths } from "./url/join";
@@ -35,7 +36,8 @@ export {
   MemoryList,
   MemoryPower,
   MemorySimple,
-  default2 as Subscriber,
+  default2 as Neo4j,
+  default3 as Subscriber,
   Union,
   clamp,
   classnames,

package/lib/neo4j.js

@@ -0,0 +1,147 @@
+import { hash8strings } from "./convert/strings";
+import { MemoryList } from "./memory/list";
+import { MemorySimple } from "./memory/simple";
+class Neo4j {
+  #nid;
+  #sourceKey;
+  #targetKey;
+  #nodes;
+  #edges;
+  #sources;
+  #targets;
+  #dirs;
+  /**
+   * 点视图
+   */
+  nodes;
+  /**
+   * 边视图
+   */
+  edges;
+  /**
+   * (边)出点视图
+   */
+  sources;
+  /**
+   * (边)入点视图
+   */
+  targets;
+  /**
+   * (边)方向视图
+   */
+  dirs;
+  constructor(nodeList, edgeList, {
+    nid,
+    eid,
+    sourceKey,
+    targetKey,
+    dir
+  }) {
+    shield(this, "nodes", this.#nodes = new MemorySimple(this.#nid = nid));
+    shield(this, "edges", this.#edges = new MemorySimple(eid));
+    shield(this, "sources", this.#sources = new MemoryList(this.#sourceKey = sourceKey));
+    shield(this, "targets", this.#targets = new MemoryList(this.#targetKey = targetKey));
+    shield(this, "dirs", this.#dirs = new MemoryList(dir));
+    nodeList.forEach((node) => this.node("add", node));
+    edgeList.forEach((edge) => this.edge("add", edge));
+  }
+  node(type, value) {
+    const nodes = this.#nodes;
+    if (type === "add") {
+      nodes.push(value);
+    } else if (type === "delete") {
+      const node = nodes.get(value);
+      if (!node)
+        return [];
+      nodes.delete(node);
+      const id = node[this.#nid];
+      const sourceKey = this.#sourceKey;
+      const targetKey = this.#targetKey;
+      const edges = this.#edges;
+      const sources = this.#sources;
+      const targets = this.#targets;
+      const dirs = this.#dirs;
+      const list = [];
+      sources.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        targets.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && sources.deleteType(id);
+      targets.get(id)?.reduce((_, edge) => {
+        edges.delete(edge);
+        sources.delete(edge);
+        edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+        list.push(edge);
+        return true;
+      }, false) && targets.deleteType(id);
+      return list;
+    }
+  }
+  edge(type, value) {
+    const sourceKey = this.#sourceKey;
+    const targetKey = this.#targetKey;
+    const edges = this.#edges;
+    const sources = this.#sources;
+    const targets = this.#targets;
+    const dirs = this.#dirs;
+    if (type === "add") {
+      const edge = value;
+      edges.push(edge);
+      sources.push(edge);
+      targets.push(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.push(edge);
+    } else if (type === "delete") {
+      const edge = edges.get(value);
+      if (!edge)
+        return false;
+      edges.delete(edge);
+      sources.delete(edge);
+      targets.delete(edge);
+      edge[sourceKey] === edge[targetKey] || dirs.delete(edge);
+      return true;
+    }
+  }
+  /**
+   * 清理图管理数据
+   */
+  clear() {
+    this.#nodes.clear();
+    this.#edges.clear();
+    this.#sources.clear();
+    this.#targets.clear();
+    this.#dirs.clear();
+  }
+}
+const shield_keys = hash8strings([
+  "push",
+  "delete",
+  "deleteType",
+  "clear"
+]);
+const shield = (obj, key, origin) => {
+  const proxy = new Proxy({}, {
+    get(target, p) {
+      if (p in shield_keys)
+        return;
+      const value = origin[p];
+      if (typeof value === "function") {
+        return function(...args) {
+          const result = origin[p](...args);
+          return result === origin ? proxy : result;
+        };
+      } else {
+        return value;
+      }
+    }
+  });
+  Object.defineProperty(obj, key, {
+    get() {
+      return proxy;
+    }
+  });
+};
+export {
+  Neo4j as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vope/utils",
-  "version": "1.4.19",
+  "version": "1.4.20",
   "description": "",
   "type": "module",
   "publishConfig": {
@@ -49,6 +49,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@type-challenges/utils": "^0.1.1",
     "@types/lodash-es": "^4.17.9",
     "@vope/types": "^1.0.12",
     "csstype": "^3.1.3",

package/types/index.d.ts

@@ -17,6 +17,7 @@ export { MemoryBasic } from './memory/basic';
 export { MemoryList } from './memory/list';
 export { MemoryPower } from './memory/power';
 export { MemorySimple } from './memory/simple';
+export { default as Neo4j } from './neo4j';
 export { once } from './once';
 export { parseNum } from './parse/num';
 export { deconPowersSum } from './power/decon';

package/types/neo4j.d.ts

@@ -0,0 +1,62 @@
+import { Equal } from '@type-challenges/utils';
+import { GetGivenProps } from '@vope/types';
+import { MemoryList } from './memory/list';
+import { MemorySimple } from './memory/simple';
+interface Config<INode extends object, IEdge extends object> {
+    nid: GetGivenProps<INode, string> & string;
+    eid: GetGivenProps<IEdge, string> & string;
+    sourceKey: GetGivenProps<IEdge, string> & string;
+    targetKey: GetGivenProps<IEdge, string> & string;
+    dir(edge: IEdge): string;
+}
+/**
+ * 图管理
+ */
+export default class Neo4j<INode extends object, IEdge extends object> {
+    #private;
+    /**
+     * 点视图
+     */
+    nodes: Shield<MemorySimple<INode, string>>;
+    /**
+     * 边视图
+     */
+    edges: Shield<MemorySimple<IEdge, string>>;
+    /**
+     * (边)出点视图
+     */
+    sources: Shield<MemoryList<IEdge, string>>;
+    /**
+     * (边)入点视图
+     */
+    targets: Shield<MemoryList<IEdge, string>>;
+    /**
+     * (边)方向视图
+     */
+    dirs: Shield<MemoryList<IEdge, string>>;
+    constructor(nodeList: INode[], edgeList: IEdge[], { nid, eid, sourceKey, targetKey, dir, }: Config<INode, IEdge>);
+    /**
+     * 点操作
+     */
+    node(type: 'add', value: INode): void;
+    node(type: 'delete', value: string): IEdge[];
+    /**
+     * 边操作
+     */
+    edge(type: 'add', value: IEdge): void;
+    edge(type: 'delete', value: string): boolean;
+    /**
+     * 清理图管理数据
+     */
+    clear(): void;
+}
+declare const shield_keys: {
+    push: number;
+    clear: number;
+    delete: number;
+    deleteType: number;
+};
+type Shield<T> = {
+    [P in Exclude<keyof T, keyof typeof shield_keys>]: T[P] extends (...args: infer A) => infer B ? Equal<B, T> extends true ? (...args: A) => Shield<T> : T[P] : T[P];
+};
+export {};