@knotx/data 0.0.1

package/dist/index.cjs

@@ -0,0 +1,807 @@
+'use strict';
+
+const rxjs = require('rxjs');
+const operators = require('rxjs/operators');
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class DataManager {
+  constructor(tag) {
+    this.tag = tag;
+    __publicField$1(this, "operations$", new rxjs.Subject());
+    __publicField$1(this, "operationPipes$", new rxjs.BehaviorSubject({
+      transform: [],
+      preOperation: [],
+      postOperation: []
+    }));
+    __publicField$1(this, "drafts$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "dataMap$", new rxjs.BehaviorSubject(/* @__PURE__ */ new Map()));
+    __publicField$1(this, "currentDraftDataMap$", new rxjs.BehaviorSubject(void 0));
+    /**
+     * 数据版本号，用于标识数据的变化，数据更新时，patchVersion 会递增
+     */
+    __publicField$1(this, "patchVersion$", new rxjs.BehaviorSubject(0));
+    /**
+     * 数据版本号，用于标识数据的变化，数据增删时，mapVersion 会递增
+     */
+    __publicField$1(this, "mapVersion$", new rxjs.BehaviorSubject(0));
+    __publicField$1(this, "_patchVersionUpdating", false);
+    __publicField$1(this, "_mapVersionUpdating", false);
+  }
+  get version() {
+    return this.patchVersion$.value + this.mapVersion$.value;
+  }
+  getDataList$() {
+    return this.dataMap$.pipe(
+      operators.map((dataMap) => Array.from(dataMap.values()))
+    );
+  }
+  getDataList() {
+    return Array.from(this.dataMap$.value.values());
+  }
+  getData$(id, equal = Object.is) {
+    return this.dataMap$.pipe(
+      operators.map((dataMap) => dataMap.get(id)),
+      operators.distinctUntilChanged(equal)
+    );
+  }
+  getData(id) {
+    return this.dataMap$.value.get(id);
+  }
+  addDataOperationPipe(pipe2) {
+    const currentPipes = this.operationPipes$.value;
+    if (pipe2.transform) {
+      currentPipes.transform.push(pipe2.transform);
+    }
+    if (pipe2.preOperation) {
+      currentPipes.preOperation.push(pipe2.preOperation);
+    }
+    if (pipe2.postOperation) {
+      currentPipes.postOperation.push(pipe2.postOperation);
+    }
+    this.operationPipes$.next(currentPipes);
+  }
+  init(initialDataList = []) {
+    this.operations$.pipe(
+      // 执行预设转换管道
+      rxjs.pipe(...this.operationPipes$.value.transform.map((pipe2) => pipe2(this.operations$))),
+      // 执行预处理管道
+      rxjs.pipe(...this.operationPipes$.value.preOperation.map((pipe2) => pipe2(this.operations$))),
+      // 更新版本号
+      operators.tap((operation) => this.updateVersion(operation)),
+      operators.scan((dataMap, operation) => this.applyOperation(dataMap, operation), this.dataMap$.value),
+      operators.map((dataMap) => ({ dataMap, operations: [] })),
+      // 执行后处理管道
+      rxjs.pipe(...this.operationPipes$.value.postOperation.map((pipe2) => pipe2(this.operations$))),
+      // 更新版本号
+      operators.tap(({ operations }) => this.updateVersion({ type: "batch", operations })),
+      operators.map(({ dataMap, operations }) => this.applyOperation(dataMap, { type: "batch", operations }))
+    ).subscribe(this.dataMap$);
+    this.operations$.next({ type: "batch", operations: initialDataList.map((data) => ({ type: "add", data })), isInit: true });
+  }
+  getOperations$() {
+    return this.operations$.asObservable();
+  }
+  dispatch(operation) {
+    this.operations$.next(operation);
+  }
+  getDraftDataList(draftId) {
+    const draftDataMap = this.drafts$.value.get(draftId);
+    return draftDataMap ? Array.from(draftDataMap.value.values()).filter((data) => data !== false) : void 0;
+  }
+  getDraftData(draftId, dataId) {
+    const draftDataMap = this.drafts$.value.get(draftId);
+    const data = draftDataMap == null ? void 0 : draftDataMap.value.get(dataId);
+    if (data === false) {
+      return void 0;
+    }
+    return data;
+  }
+  getCurrentDraftData(dataId) {
+    var _a;
+    const data = (_a = this.currentDraftDataMap$.value) == null ? void 0 : _a.get(dataId);
+    if (data === false) {
+      return void 0;
+    }
+    return data;
+  }
+  applyOperation(dataMap, operation) {
+    switch (operation.type) {
+      case "add":
+        dataMap.delete(operation.data.id);
+        dataMap.set(operation.data.id, operation.data);
+        break;
+      case "remove":
+        dataMap.delete(operation.id);
+        break;
+      case "update": {
+        const current = dataMap.get(operation.id);
+        if (current) {
+          dataMap.set(operation.id, __spreadValues$1(__spreadValues$1({}, current), operation.data));
+        }
+        break;
+      }
+      case "batch":
+        operation.operations.reduce(
+          (acc, op) => this.applyOperation(acc, op),
+          dataMap
+        );
+        break;
+      case "startDraft": {
+        const draftDataMap$ = new rxjs.BehaviorSubject(/* @__PURE__ */ new Map());
+        this.drafts$.next(this.drafts$.value.set(operation.draftId, draftDataMap$));
+        this.currentDraftDataMap$.next(draftDataMap$.value);
+        break;
+      }
+      case "draftOperation": {
+        const draftDataMap = this.drafts$.value.get(operation.draftId);
+        if (draftDataMap) {
+          this.applyOperation(new Proxy(draftDataMap.value, {
+            get(target, prop) {
+              const draft = target;
+              switch (prop) {
+                case "get":
+                  return (id) => {
+                    if (!draft.has(id)) {
+                      return dataMap.get(id);
+                    }
+                    return draft.get(id) || void 0;
+                  };
+                case "set":
+                  return (id, value) => draft.set(id, value);
+                case "delete":
+                  return (id) => draft.set(id, false);
+                default:
+                  return Reflect.get(target, prop);
+              }
+            }
+          }), operation.operation);
+          this.currentDraftDataMap$.next(draftDataMap.value);
+        }
+        break;
+      }
+      case "commitDraft": {
+        const draftData = this.drafts$.value.get(operation.draftId);
+        if (draftData) {
+          const operations = [];
+          draftData.value.forEach((data, id) => {
+            if (data === false) {
+              if (dataMap.has(id)) {
+                operations.push({ type: "remove", id });
+              }
+              return;
+            }
+            if (!dataMap.has(id)) {
+              operations.push({ type: "add", data });
+              return;
+            }
+            const currentData = dataMap.get(id);
+            if (!Object.is(currentData, data)) {
+              operations.push({ type: "update", id, data });
+            }
+          });
+          if (operations.length > 0) {
+            this.dispatch({ type: "batch", operations });
+          }
+          this.drafts$.value.delete(operation.draftId);
+          this.drafts$.next(this.drafts$.value);
+          if (this.currentDraftDataMap$.value === draftData.value) {
+            this.currentDraftDataMap$.next(void 0);
+          }
+        }
+        break;
+      }
+      case "discardDraft": {
+        this.drafts$.value.delete(operation.draftId);
+        this.drafts$.next(this.drafts$.value);
+        const draftData = this.drafts$.value.get(operation.draftId);
+        if (this.currentDraftDataMap$.value === (draftData == null ? void 0 : draftData.value)) {
+          this.currentDraftDataMap$.next(void 0);
+        }
+        break;
+      }
+    }
+    return dataMap;
+  }
+  updateVersion(operation, scheduler = queueMicrotask) {
+    if (this.isPatchOperation(operation)) {
+      if (this._patchVersionUpdating) {
+        return;
+      }
+      this._patchVersionUpdating = true;
+      scheduler(() => {
+        this.patchVersion$.next(this.patchVersion$.value + 1);
+        this._patchVersionUpdating = false;
+      });
+    }
+    if (this.isMapOperation(operation)) {
+      if (this._mapVersionUpdating) {
+        return;
+      }
+      this._mapVersionUpdating = true;
+      scheduler(() => {
+        this.mapVersion$.next(this.mapVersion$.value + 1);
+        this._mapVersionUpdating = false;
+      });
+    }
+  }
+  isPatchOperation(operation) {
+    switch (operation.type) {
+      case "update":
+        return true;
+      case "batch": {
+        return operation.isInit ? false : operation.operations.some((op) => this.isPatchOperation(op));
+      }
+    }
+    return false;
+  }
+  isMapOperation(operation) {
+    switch (operation.type) {
+      case "add":
+      case "remove":
+        return true;
+      case "batch": {
+        return operation.isInit ? false : operation.operations.some((op) => this.isMapOperation(op));
+      }
+    }
+    return false;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ChangeType = /* @__PURE__ */ ((ChangeType2) => {
+  ChangeType2["ADD"] = "add";
+  ChangeType2["REMOVE"] = "remove";
+  return ChangeType2;
+})(ChangeType || {});
+class DualRelation {
+  constructor(options = {}) {
+    __publicField(this, "parentToChildren");
+    // 父节点到子节点集合的映射
+    __publicField(this, "childToParent");
+    // 子节点到父节点的映射
+    __publicField(this, "_version", 0);
+    // 内部版本计数器
+    __publicField(this, "_versionSubject");
+    // 版本变更的Observable
+    __publicField(this, "_batchUpdateMode", false);
+    // 是否处于批量更新模式
+    __publicField(this, "_hasPendingChanges", false);
+    // 是否有待处理的变更
+    __publicField(this, "_changeHistory", []);
+    // 变更历史记录
+    __publicField(this, "_options");
+    // 配置选项
+    __publicField(this, "_pendingChanges", []);
+    // 批量模式下的待处理变更
+    __publicField(this, "_nodeLevels", /* @__PURE__ */ new Map());
+    // 节点层级映射
+    __publicField(this, "_needsLevelRecalculation", false);
+    var _a, _b;
+    this.parentToChildren = /* @__PURE__ */ new Map();
+    this.childToParent = /* @__PURE__ */ new Map();
+    this._versionSubject = new rxjs.BehaviorSubject(this._version);
+    this._options = {
+      allowEmptyParent: (_a = options.allowEmptyParent) != null ? _a : false,
+      historyDepth: (_b = options.historyDepth) != null ? _b : 10
+    };
+  }
+  // 是否需要重新计算所有层级
+  /**
+   * 获取版本变更的Observable
+   */
+  get version() {
+    return this._versionSubject;
+  }
+  /**
+   * 获取变更历史记录
+   */
+  get changeHistory() {
+    return this._changeHistory;
+  }
+  /**
+   * 更新配置选项
+   * @param options 新的配置选项
+   */
+  updateOptions(options) {
+    this._options = __spreadValues(__spreadValues({}, this._options), options);
+    if (options.historyDepth !== void 0 && this._changeHistory.length > options.historyDepth) {
+      this._changeHistory = this._changeHistory.slice(-options.historyDepth);
+    }
+  }
+  /**
+   * 获取节点的层级
+   * 层级定义：
+   * 0: 不在关系中的节点
+   * 1: 顶层父节点(没有父节点的节点)
+   * n > 1: 子节点的层级是其父节点的层级 + 1
+   * @param node 要查询的节点
+   * @returns 节点的层级
+   */
+  getNodeLevel(node) {
+    if (this._needsLevelRecalculation) {
+      this.recalculateAllLevels();
+    }
+    return this._nodeLevels.get(node) || 0;
+  }
+  /**
+   * 重新计算所有节点的层级
+   * @private
+   */
+  recalculateAllLevels() {
+    this._nodeLevels.clear();
+    for (const parent of this.parentToChildren.keys()) {
+      if (!this.childToParent.has(parent)) {
+        this._nodeLevels.set(parent, 1);
+      }
+    }
+    const processed = /* @__PURE__ */ new Set();
+    let currentLevel = 1;
+    let currentLevelNodes = Array.from(this._nodeLevels.keys());
+    while (currentLevelNodes.length > 0) {
+      const nextLevelNodes = [];
+      currentLevel++;
+      for (const node of currentLevelNodes) {
+        processed.add(node);
+        const children = this.getChildren(node);
+        for (const child of children) {
+          if (!processed.has(child)) {
+            this._nodeLevels.set(child, currentLevel);
+            nextLevelNodes.push(child);
+          }
+        }
+      }
+      currentLevelNodes = nextLevelNodes;
+    }
+    this._needsLevelRecalculation = false;
+  }
+  /**
+   * 更新节点层级
+   * @param node 要更新的节点
+   * @param parent 节点的父节点
+   * @private
+   */
+  updateNodeLevel(node, parent) {
+    if (!parent) {
+      this._nodeLevels.delete(node);
+      return;
+    }
+    let parentLevel = this._nodeLevels.get(parent);
+    if (parentLevel === void 0) {
+      const grandParent = this.getParent(parent);
+      if (grandParent) {
+        this.updateNodeLevel(parent, grandParent);
+        parentLevel = this._nodeLevels.get(parent);
+      } else {
+        parentLevel = 1;
+        this._nodeLevels.set(parent, parentLevel);
+      }
+    }
+    if (parentLevel === void 0) {
+      this._needsLevelRecalculation = true;
+      parentLevel = 1;
+    }
+    this._nodeLevels.set(node, parentLevel + 1);
+    this.updateChildrenLevels(node, parentLevel + 1);
+  }
+  /**
+   * 递归更新所有子节点的层级
+   * @param parent 父节点
+   * @param parentLevel 父节点的层级
+   * @private
+   */
+  updateChildrenLevels(parent, parentLevel) {
+    const children = this.getChildren(parent);
+    for (const child of children) {
+      const childLevel = parentLevel + 1;
+      this._nodeLevels.set(child, childLevel);
+      this.updateChildrenLevels(child, childLevel);
+    }
+  }
+  /**
+   * 记录变更
+   * @param parent 父节点
+   * @param children 子节点数组
+   * @param type 变更类型
+   * @private
+   */
+  recordChange(parent, children, type) {
+    const change = {
+      parent,
+      children: [...children],
+      type,
+      timestamp: Date.now()
+    };
+    if (this._batchUpdateMode) {
+      this._pendingChanges.push(change);
+    } else {
+      this._changeHistory.push(change);
+      if (this._changeHistory.length > this._options.historyDepth) {
+        this._changeHistory.shift();
+      }
+    }
+  }
+  /**
+   * 更新版本号，用于通知外部关系发生了变化
+   * @private
+   */
+  updateVersion() {
+    if (this._batchUpdateMode) {
+      this._hasPendingChanges = true;
+      return;
+    }
+    this._version++;
+    this._versionSubject.next(this._version);
+  }
+  /**
+   * 开始批量更新操作
+   * 在此模式下，所有导致版本变更的操作将被延迟，直到调用commitBatch
+   */
+  beginBatch() {
+    this._batchUpdateMode = true;
+    this._hasPendingChanges = false;
+    this._pendingChanges = [];
+  }
+  /**
+   * 提交批量更新，如果有变更则更新版本
+   * @returns 是否有变更被提交
+   */
+  commitBatch() {
+    if (!this._batchUpdateMode) {
+      return false;
+    }
+    this._batchUpdateMode = false;
+    if (this._hasPendingChanges) {
+      for (const change of this._pendingChanges) {
+        this._changeHistory.push(change);
+        if (this._changeHistory.length > this._options.historyDepth) {
+          this._changeHistory.shift();
+        }
+      }
+      this._pendingChanges = [];
+      this._version++;
+      this._versionSubject.next(this._version);
+      this._hasPendingChanges = false;
+      if (this._needsLevelRecalculation) {
+        this.recalculateAllLevels();
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 回滚批量更新，取消所有未提交的变更
+   * 注意：此方法不会撤销已执行的关系变更，只会阻止版本更新
+   */
+  rollbackBatch() {
+    this._batchUpdateMode = false;
+    this._hasPendingChanges = false;
+    this._pendingChanges = [];
+  }
+  /**
+   * 在批量模式中执行多个操作并自动提交
+   * @param operations 要执行的函数
+   * @returns 批量操作是否导致了版本变更
+   */
+  batch(operations) {
+    this.beginBatch();
+    try {
+      operations();
+      return this.commitBatch();
+    } catch (error) {
+      this.rollbackBatch();
+      throw error;
+    }
+  }
+  /**
+   * 添加父子关系
+   * @param parent 父节点
+   * @param child 子节点
+   */
+  add(parent, child) {
+    const hadParent = this.childToParent.has(child);
+    const oldParent = hadParent ? this.childToParent.get(child) : null;
+    const isNewRelation = !hadParent || oldParent !== parent;
+    if (!isNewRelation) {
+      return;
+    }
+    if (this.childToParent.has(child)) {
+      const oldParent2 = this.childToParent.get(child);
+      const children = this.parentToChildren.get(oldParent2);
+      if (children) {
+        children.delete(child);
+        if (children.size === 0 && !this._options.allowEmptyParent) {
+          this.parentToChildren.delete(oldParent2);
+          if (!this.childToParent.has(oldParent2)) {
+            this._nodeLevels.delete(oldParent2);
+          }
+        }
+        this.recordChange(oldParent2, [child], "remove" /* REMOVE */);
+      }
+    }
+    if (!this.parentToChildren.has(parent)) {
+      this.parentToChildren.set(parent, /* @__PURE__ */ new Set());
+      if (!this.childToParent.has(parent)) {
+        this._nodeLevels.set(parent, 1);
+      }
+    }
+    this.parentToChildren.get(parent).add(child);
+    this.childToParent.set(child, parent);
+    this.updateNodeLevel(child, parent);
+    this.recordChange(parent, [child], "add" /* ADD */);
+    this.updateVersion();
+  }
+  /**
+   * 移除子节点及其父关系
+   * @param child 子节点
+   * @returns 是否成功移除
+   */
+  removeChild(child) {
+    if (!this.childToParent.has(child)) {
+      return false;
+    }
+    const parent = this.childToParent.get(child);
+    const children = this.parentToChildren.get(parent);
+    if (children) {
+      children.delete(child);
+      if (children.size === 0 && !this._options.allowEmptyParent) {
+        this.parentToChildren.delete(parent);
+      }
+    }
+    this.childToParent.delete(child);
+    this._nodeLevels.delete(child);
+    if (this.parentToChildren.has(child)) {
+      this._needsLevelRecalculation = true;
+    }
+    this.recordChange(parent, [child], "remove" /* REMOVE */);
+    this.updateVersion();
+    return true;
+  }
+  /**
+   * 移除父节点及其所有子节点的关系
+   * @param parent 父节点
+   * @returns 是否成功移除
+   */
+  removeParent(parent) {
+    if (!this.parentToChildren.has(parent)) {
+      return false;
+    }
+    const children = this.parentToChildren.get(parent);
+    const childrenArray = Array.from(children);
+    for (const child of children) {
+      if (this.parentToChildren.has(child)) {
+        this._needsLevelRecalculation = true;
+        break;
+      }
+    }
+    children.forEach((child) => {
+      this.childToParent.delete(child);
+      this._nodeLevels.delete(child);
+    });
+    this.parentToChildren.delete(parent);
+    if (!this.childToParent.has(parent)) {
+      this._nodeLevels.delete(parent);
+    }
+    this.recordChange(parent, childrenArray, "remove" /* REMOVE */);
+    this.updateVersion();
+    return true;
+  }
+  /**
+   * 清空所有关系并清除历史记录
+   * @param clearHistory 是否清除历史记录，默认为true
+   */
+  clear(clearHistory = true) {
+    if (this.parentToChildren.size > 0 || this.childToParent.size > 0) {
+      if (!clearHistory) {
+        for (const [parent, children] of this.parentToChildren.entries()) {
+          this.recordChange(parent, Array.from(children), "remove" /* REMOVE */);
+        }
+      }
+      this.parentToChildren.clear();
+      this.childToParent.clear();
+      this._nodeLevels.clear();
+      this._needsLevelRecalculation = false;
+      if (clearHistory) {
+        this._changeHistory = [];
+      }
+      this.updateVersion();
+    }
+  }
+  /**
+   * 获取所有子节点
+   * @param parent 父节点
+   * @returns 子节点集合
+   */
+  getChildren(parent) {
+    return this.parentToChildren.get(parent) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * 获取父节点
+   * @param child 子节点
+   * @returns 父节点，如果不存在则返回undefined
+   */
+  getParent(child) {
+    return this.childToParent.get(child);
+  }
+  /**
+   * 获取根节点
+   * @param node 子节点
+   * @returns 根节点，如果节点无父节点则返回该节点本身，如果检测到循环引用则返回null
+   */
+  getRootParent(node) {
+    if (!this.childToParent.has(node)) {
+      return node;
+    }
+    const visited = /* @__PURE__ */ new Set();
+    let current = node;
+    while (true) {
+      visited.add(current);
+      const parent = this.childToParent.get(current);
+      if (!parent) {
+        return current;
+      }
+      if (visited.has(parent)) {
+        return null;
+      }
+      current = parent;
+    }
+  }
+  /**
+   * 检查是否存在循环引用
+   * @returns 是否存在循环引用
+   */
+  hasCircularReference() {
+    for (const child of this.childToParent.keys()) {
+      const visited = /* @__PURE__ */ new Set();
+      let current = child;
+      while (true) {
+        visited.add(current);
+        const parent = this.childToParent.get(current);
+        if (!parent) {
+          break;
+        }
+        if (visited.has(parent)) {
+          return true;
+        }
+        current = parent;
+      }
+    }
+    return false;
+  }
+  /**
+   * 添加父子关系，但会检查是否会形成循环引用
+   * @param parent 父节点
+   * @param child 子节点
+   * @returns 是否成功添加关系（如果会形成循环引用则返回false）
+   */
+  addSafe(parent, child) {
+    if (parent === child) {
+      return false;
+    }
+    if (this.isAncestorOf(child, parent)) {
+      return false;
+    }
+    this.add(parent, child);
+    return true;
+  }
+  /**
+   * 检查节点A是否是节点B的祖先节点
+   * @param nodeA 可能的祖先节点
+   * @param nodeB 待检查节点
+   * @returns 是否是祖先关系
+   */
+  isAncestorOf(nodeA, nodeB) {
+    if (!this.parentToChildren.has(nodeB)) {
+      return false;
+    }
+    const queue = [nodeB];
+    const visited = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const current = queue.shift();
+      visited.add(current);
+      const parent = this.getParent(current);
+      if (parent === nodeA) {
+        return true;
+      }
+      if (parent && !visited.has(parent)) {
+        queue.push(parent);
+      }
+    }
+    return false;
+  }
+  /**
+   * 获取所有父节点
+   * @returns 父节点集合
+   */
+  getAllParents() {
+    return new Set(this.parentToChildren.keys());
+  }
+  /**
+   * 获取所有子节点
+   * @returns 子节点集合
+   */
+  getAllChildren() {
+    return new Set(this.childToParent.keys());
+  }
+  /**
+   * 检查父子关系是否存在
+   * @param parent 父节点
+   * @param child 子节点
+   * @returns 是否存在关系
+   */
+  hasRelation(parent, child) {
+    const children = this.parentToChildren.get(parent);
+    return children ? children.has(child) : false;
+  }
+  /**
+   * 获取关系数量
+   * @returns 关系数量
+   */
+  size() {
+    return this.childToParent.size;
+  }
+  /**
+   * 获取指定节点的所有后代节点（包括子节点、孙节点等）
+   * @param parent 父节点
+   * @param includeSelf 是否包含自身，默认为false
+   * @returns 所有后代节点的集合
+   */
+  getDescendants(parent, includeSelf = false) {
+    const result = /* @__PURE__ */ new Set();
+    if (!this.parentToChildren.has(parent)) {
+      return result;
+    }
+    const queue = [parent];
+    const visitedParents = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const current = queue.shift();
+      visitedParents.add(current);
+      const children = this.getChildren(current);
+      for (const child of children) {
+        result.add(child);
+        if (this.parentToChildren.has(child) && !visitedParents.has(child)) {
+          queue.push(child);
+        }
+      }
+    }
+    if (includeSelf) {
+      result.add(parent);
+    }
+    return result;
+  }
+}
+
+exports.ChangeType = ChangeType;
+exports.DataManager = DataManager;
+exports.DualRelation = DualRelation;