@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/graphlib/esm/graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.js","sources":["../../../../../node_modules/@antv/graphlib/esm/graph.js"],"sourcesContent":["import EventEmitter from '@antv/event-emitter';\nimport { GraphView } from './graphView';\nimport { doBFS, doDFS } from './utils/traverse';\nexport class Graph extends EventEmitter {\n    nodeMap = new Map();\n    edgeMap = new Map();\n    inEdgesMap = new Map();\n    outEdgesMap = new Map();\n    bothEdgesMap = new Map();\n    treeIndices = new Map();\n    changes = [];\n    batchCount = 0;\n    /**\n     * This function is called with a {@link GraphChangedEvent} each time a graph change happened.\n     *\n     * `event.changes` contains all the graph changes in order since last `onChanged`.\n     */\n    onChanged = () => {\n        // Do nothing.\n    };\n    /**\n     * Create a new Graph instance.\n     * @param options - The options to initialize a graph. See {@link GraphOptions}.\n     *\n     * ```ts\n     * const graph = new Graph({\n     *   // Optional, initial nodes.\n     *   nodes: [\n     *     // Each node has a unique ID.\n     *     { id: 'A', foo: 1 },\n     *     { id: 'B', foo: 1 },\n     *   ],\n     *   // Optional, initial edges.\n     *   edges: [\n     *     { id: 'C', source: 'B', target: 'B', weight: 1 },\n     *   ],\n     *   // Optional, called with a GraphChangedEvent.\n     *   onChanged: (event) => {\n     *     console.log(event);\n     *   }\n     * });\n     * ```\n     */\n    constructor(options) {\n        super();\n        if (!options)\n            return;\n        if (options.nodes)\n            this.addNodes(options.nodes);\n        if (options.edges)\n            this.addEdges(options.edges);\n        if (options.tree)\n            this.addTree(options.tree);\n        if (options.onChanged)\n            this.onChanged = options.onChanged;\n    }\n    /**\n     * Batch several graph changes into one.\n     *\n     * Make several changes, but dispatch only one ChangedEvent at the end of batch:\n     * ```ts\n     * graph.batch(() => {\n     *   graph.addNodes([]);\n     *   graph.addEdges([]);\n     * });\n     * ```\n     *\n     * Batches can be nested. Only the outermost batch will dispatch a ChangedEvent:\n     * ```ts\n     * graph.batch(() => {\n     *   graph.addNodes([]);\n     *   graph.batch(() => {\n     *     graph.addEdges([]);\n     *   });\n     * });\n     * ```\n     */\n    batch = (fn) => {\n        this.batchCount += 1;\n        fn();\n        this.batchCount -= 1;\n        if (!this.batchCount) {\n            this.commit();\n        }\n    };\n    /**\n     * Reset changes and dispatch a ChangedEvent.\n     */\n    commit() {\n        const changes = this.changes;\n        this.changes = [];\n        const event = {\n            graph: this,\n            changes,\n        };\n        this.emit('changed', event);\n        this.onChanged(event);\n    }\n    /**\n     * Reduce the number of ordered graph changes by dropping or merging unnecessary changes.\n     *\n     * For example, if we update a node and remove it in a batch:\n     *\n     * ```ts\n     * graph.batch(() => {\n     *   graph.updateNodeData('A', 'foo', 2);\n     *   graph.removeNode('A');\n     * });\n     * ```\n     *\n     * We get 2 atomic graph changes like\n     *\n     * ```ts\n     * [\n     *   { type: 'NodeDataUpdated', id: 'A', propertyName: 'foo', oldValue: 1, newValue: 2 },\n     *   { type: 'NodeRemoved', value: { id: 'A', data: { foo: 2 } },\n     * ]\n     * ```\n     *\n     * Since node 'A' has been removed, we actually have no need to handle with NodeDataUpdated change.\n     *\n     * `reduceChanges()` here helps us remove such changes.\n     */\n    reduceChanges(changes) {\n        let mergedChanges = [];\n        changes.forEach((change) => {\n            switch (change.type) {\n                case 'NodeRemoved': {\n                    // NodeAdded: A added.\n                    // NodeDataUpdated: A changed.\n                    // TreeStructureChanged: A's parent changed.\n                    // NodeRemoved: A removed. 👈🏻 Since A was removed, above three changes may be ignored.\n                    let isNewlyAdded = false;\n                    mergedChanges = mergedChanges.filter((pastChange) => {\n                        if (pastChange.type === 'NodeAdded') {\n                            const sameId = pastChange.value.id === change.value.id;\n                            if (sameId) {\n                                isNewlyAdded = true;\n                            }\n                            return !sameId;\n                        }\n                        else if (pastChange.type === 'NodeDataUpdated') {\n                            return pastChange.id !== change.value.id;\n                        }\n                        else if (pastChange.type === 'TreeStructureChanged') {\n                            return pastChange.nodeId !== change.value.id;\n                        }\n                        return true;\n                    });\n                    if (!isNewlyAdded) {\n                        mergedChanges.push(change);\n                    }\n                    break;\n                }\n                case 'EdgeRemoved': {\n                    // EdgeAdded: A added.\n                    // EdgeDataUpdated: A changed.\n                    // EdgeDataUpdated: A's source/target changed.\n                    // EdgeRemoved: A removed. 👈🏻 Since A was removed, above three changes may be ignored.\n                    let isNewlyAdded = false;\n                    mergedChanges = mergedChanges.filter((pastChange) => {\n                        if (pastChange.type === 'EdgeAdded') {\n                            const sameId = pastChange.value.id === change.value.id;\n                            if (sameId) {\n                                isNewlyAdded = true;\n                            }\n                            return !sameId;\n                        }\n                        else if (pastChange.type === 'EdgeDataUpdated' ||\n                            pastChange.type === 'EdgeUpdated') {\n                            return pastChange.id !== change.value.id;\n                        }\n                        return true;\n                    });\n                    if (!isNewlyAdded) {\n                        mergedChanges.push(change);\n                    }\n                    break;\n                }\n                case 'NodeDataUpdated':\n                case 'EdgeDataUpdated':\n                case 'EdgeUpdated': {\n                    // NodeDataUpdated: { id: A, propertyName: 'foo', oldValue: 1, newValue: 2 }.\n                    // NodeDataUpdated: { id: A, propertyName: 'foo', oldValue: 2, newValue: 3 }.\n                    // 👆 Could be merged as { id: A, propertyName: 'foo', oldValue: 1, newValue: 3 }.\n                    const index = mergedChanges.findIndex((pastChange) => {\n                        return (pastChange.type === change.type &&\n                            pastChange.id === change.id &&\n                            (change.propertyName === undefined ||\n                                pastChange.propertyName === change.propertyName));\n                    });\n                    const existingChange = mergedChanges[index];\n                    if (existingChange) {\n                        if (change.propertyName !== undefined) {\n                            // The incoming change is of the same property of existing change.\n                            existingChange.newValue = change.newValue;\n                        }\n                        else {\n                            // The incoming change is a whole data override.\n                            mergedChanges.splice(index, 1);\n                            mergedChanges.push(change);\n                        }\n                    }\n                    else {\n                        mergedChanges.push(change);\n                    }\n                    break;\n                }\n                case 'TreeStructureDetached': {\n                    // TreeStructureAttached\n                    // TreeStructureChanged\n                    // TreeStructureDetached 👈🏻 Since the tree struct was detached, above 2 changes may be ignored.\n                    mergedChanges = mergedChanges.filter((pastChange) => {\n                        if (pastChange.type === 'TreeStructureAttached') {\n                            return pastChange.treeKey !== change.treeKey;\n                        }\n                        else if (pastChange.type === 'TreeStructureChanged') {\n                            return pastChange.treeKey !== change.treeKey;\n                        }\n                        return true;\n                    });\n                    mergedChanges.push(change);\n                    break;\n                }\n                case 'TreeStructureChanged': {\n                    const existingChange = mergedChanges.find((pastChange) => {\n                        return (pastChange.type === 'TreeStructureChanged' &&\n                            pastChange.treeKey === change.treeKey &&\n                            pastChange.nodeId === change.nodeId);\n                    });\n                    if (existingChange) {\n                        existingChange.newParentId =\n                            change.newParentId;\n                    }\n                    else {\n                        mergedChanges.push(change);\n                    }\n                    break;\n                }\n                default:\n                    mergedChanges.push(change);\n                    break;\n            }\n        });\n        return mergedChanges;\n    }\n    // ================= Node =================\n    checkNodeExistence(id) {\n        this.getNode(id);\n    }\n    /**\n     * Check if a node exists in the graph.\n     * @group NodeMethods\n     */\n    hasNode(id) {\n        return this.nodeMap.has(id);\n    }\n    /**\n     * Tell if two nodes are neighbors.\n     * @group NodeMethods\n     */\n    areNeighbors(firstNodeId, secondNodeId) {\n        return this.getNeighbors(secondNodeId).some((neighbor) => neighbor.id === firstNodeId);\n    }\n    /**\n     * Get the node data with given ID.\n     * @group NodeMethods\n     */\n    getNode(id) {\n        const node = this.nodeMap.get(id);\n        if (!node) {\n            throw new Error('Node not found for id: ' + id);\n        }\n        return node;\n    }\n    /**\n     * Given a node ID, find all edges of the node.\n     * @param id - ID of the node\n     * @param direction - Edge direction, defaults to 'both'.\n     * @group NodeMethods\n     */\n    getRelatedEdges(id, direction) {\n        this.checkNodeExistence(id);\n        if (direction === 'in') {\n            const inEdges = this.inEdgesMap.get(id);\n            return Array.from(inEdges);\n        }\n        else if (direction === 'out') {\n            const outEdges = this.outEdgesMap.get(id);\n            return Array.from(outEdges);\n        }\n        else {\n            const bothEdges = this.bothEdgesMap.get(id);\n            return Array.from(bothEdges);\n        }\n    }\n    /**\n     * Get the degree of the given node.\n     * @group NodeMethods\n     */\n    getDegree(id, direction) {\n        return this.getRelatedEdges(id, direction).length;\n    }\n    /**\n     * Get all successors of the given node.\n     */\n    getSuccessors(id) {\n        const outEdges = this.getRelatedEdges(id, 'out');\n        const targets = outEdges.map((edge) => this.getNode(edge.target));\n        return Array.from(new Set(targets));\n    }\n    /**\n     * Get all predecessors of the given node.\n     */\n    getPredecessors(id) {\n        const inEdges = this.getRelatedEdges(id, 'in');\n        const sources = inEdges.map((edge) => this.getNode(edge.source));\n        return Array.from(new Set(sources));\n    }\n    /**\n     * Given a node ID, find its neighbors.\n     * @param id - ID of the node\n     * @group NodeMethods\n     */\n    getNeighbors(id) {\n        const predecessors = this.getPredecessors(id);\n        const successors = this.getSuccessors(id);\n        return Array.from(new Set([...predecessors, ...successors]));\n    }\n    doAddNode(node) {\n        if (this.hasNode(node.id)) {\n            throw new Error('Node already exists: ' + node.id);\n        }\n        this.nodeMap.set(node.id, node);\n        this.inEdgesMap.set(node.id, new Set());\n        this.outEdgesMap.set(node.id, new Set());\n        this.bothEdgesMap.set(node.id, new Set());\n        this.treeIndices.forEach((tree) => {\n            tree.childrenMap.set(node.id, new Set());\n        });\n        this.changes.push({ type: 'NodeAdded', value: node });\n    }\n    /**\n     * Add all nodes of the given array, or iterable, into the graph.\n     * @group NodeMethods\n     */\n    addNodes(nodes) {\n        this.batch(() => {\n            for (const node of nodes) {\n                this.doAddNode(node);\n            }\n        });\n    }\n    /**\n     * Add a single node into the graph.\n     * @group NodeMethods\n     */\n    addNode(node) {\n        this.addNodes([node]);\n    }\n    doRemoveNode(id) {\n        const node = this.getNode(id);\n        const bothEdges = this.bothEdgesMap.get(id);\n        bothEdges?.forEach((edge) => this.doRemoveEdge(edge.id));\n        this.nodeMap.delete(id);\n        this.treeIndices.forEach((tree) => {\n            tree.childrenMap.get(id)?.forEach((child) => {\n                tree.parentMap.delete(child.id);\n            });\n            const parent = tree.parentMap.get(id);\n            if (parent)\n                tree.childrenMap.get(parent.id)?.delete(node);\n            tree.parentMap.delete(id);\n            tree.childrenMap.delete(id);\n        });\n        this.bothEdgesMap.delete(id);\n        this.inEdgesMap.delete(id);\n        this.outEdgesMap.delete(id);\n        this.changes.push({ type: 'NodeRemoved', value: node });\n    }\n    /**\n     * Remove nodes and their attached edges from the graph.\n     * @group NodeMethods\n     */\n    removeNodes(idList) {\n        this.batch(() => {\n            idList.forEach((id) => this.doRemoveNode(id));\n        });\n    }\n    /**\n     * Remove a single node and its attached edges from the graph.\n     * @group NodeMethods\n     */\n    removeNode(id) {\n        this.removeNodes([id]);\n    }\n    updateNodeDataProperty(id, propertyName, value) {\n        const node = this.getNode(id);\n        this.batch(() => {\n            const oldValue = node.data[propertyName];\n            const newValue = value;\n            node.data[propertyName] = newValue;\n            this.changes.push({\n                type: 'NodeDataUpdated',\n                id,\n                propertyName,\n                oldValue,\n                newValue,\n            });\n        });\n    }\n    /**\n     * Like Object.assign, merge all properties of `path` to the node data.\n     * @param id Node ID.\n     * @param patch A data object to merge.\n     */\n    mergeNodeData(id, patch) {\n        this.batch(() => {\n            Object.entries(patch).forEach(([propertyName, value]) => {\n                this.updateNodeDataProperty(id, propertyName, value);\n            });\n        });\n    }\n    updateNodeData(...args) {\n        const id = args[0];\n        const node = this.getNode(id);\n        if (typeof args[1] === 'string') {\n            // id, propertyName, value\n            this.updateNodeDataProperty(id, args[1], args[2]);\n            return;\n        }\n        let data;\n        if (typeof args[1] === 'function') {\n            // id, update\n            const update = args[1];\n            data = update(node.data);\n        }\n        else if (typeof args[1] === 'object') {\n            // id, data\n            data = args[1];\n        }\n        this.batch(() => {\n            const oldValue = node.data;\n            const newValue = data;\n            node.data = data;\n            this.changes.push({\n                type: 'NodeDataUpdated',\n                id,\n                oldValue,\n                newValue,\n            });\n        });\n    }\n    // ================= Edge =================\n    checkEdgeExistence(id) {\n        if (!this.hasEdge(id)) {\n            throw new Error('Edge not found for id: ' + id);\n        }\n    }\n    /**\n     * Check if an edge exists in the graph.\n     * @group NodeMethods\n     */\n    hasEdge(id) {\n        return this.edgeMap.has(id);\n    }\n    /**\n     * Get the edge data with given ID.\n     * @group EdgeMethods\n     */\n    getEdge(id) {\n        this.checkEdgeExistence(id);\n        return this.edgeMap.get(id);\n    }\n    /**\n     * Get the edge, the source node, and the target node by an edge ID.\n     * @group EdgeMethods\n     */\n    getEdgeDetail(id) {\n        const edge = this.getEdge(id);\n        return {\n            edge,\n            source: this.getNode(edge.source),\n            target: this.getNode(edge.target),\n        };\n    }\n    doAddEdge(edge) {\n        if (this.hasEdge(edge.id)) {\n            throw new Error('Edge already exists: ' + edge.id);\n        }\n        this.checkNodeExistence(edge.source);\n        this.checkNodeExistence(edge.target);\n        this.edgeMap.set(edge.id, edge);\n        const inEdges = this.inEdgesMap.get(edge.target);\n        const outEdges = this.outEdgesMap.get(edge.source);\n        const bothEdgesOfSource = this.bothEdgesMap.get(edge.source);\n        const bothEdgesOfTarget = this.bothEdgesMap.get(edge.target);\n        inEdges.add(edge);\n        outEdges.add(edge);\n        bothEdgesOfSource.add(edge);\n        bothEdgesOfTarget.add(edge);\n        this.changes.push({ type: 'EdgeAdded', value: edge });\n    }\n    /**\n     * Add all edges of the given iterable(an array, a set, etc.) into the graph.\n     * @group EdgeMethods\n     */\n    addEdges(edges) {\n        this.batch(() => {\n            for (const edge of edges) {\n                this.doAddEdge(edge);\n            }\n        });\n    }\n    /**\n     * Add a single edge pointing from `source` to `target` into the graph.\n     *\n     * ```ts\n     * graph.addNode({ id: 'NodeA' });\n     * graph.addNode({ id: 'NodeB' });\n     * graph.addEdge({ id: 'EdgeA', source: 'NodeA', target: 'NodeB' });\n     * ```\n     *\n     * If `source` or `target` were not found in the current graph, it throws an Error.\n     * @group EdgeMethods\n     */\n    addEdge(edge) {\n        this.addEdges([edge]);\n    }\n    doRemoveEdge(id) {\n        const edge = this.getEdge(id);\n        const outEdges = this.outEdgesMap.get(edge.source);\n        const inEdges = this.inEdgesMap.get(edge.target);\n        const bothEdgesOfSource = this.bothEdgesMap.get(edge.source);\n        const bothEdgesOfTarget = this.bothEdgesMap.get(edge.target);\n        outEdges.delete(edge);\n        inEdges.delete(edge);\n        bothEdgesOfSource.delete(edge);\n        bothEdgesOfTarget.delete(edge);\n        this.edgeMap.delete(id);\n        this.changes.push({ type: 'EdgeRemoved', value: edge });\n    }\n    /**\n     * Remove edges whose id was included in the given id list.\n     * @group EdgeMethods\n     */\n    removeEdges(idList) {\n        this.batch(() => {\n            idList.forEach((id) => this.doRemoveEdge(id));\n        });\n    }\n    /**\n     * Remove a single edge of the given id.\n     * @group EdgeMethods\n     */\n    removeEdge(id) {\n        this.removeEdges([id]);\n    }\n    /**\n     * Change the source of an edge. The source must be found in current graph.\n     * @group EdgeMethods\n     */\n    updateEdgeSource(id, source) {\n        const edge = this.getEdge(id);\n        this.checkNodeExistence(source);\n        const oldSource = edge.source;\n        const newSource = source;\n        this.outEdgesMap.get(oldSource).delete(edge);\n        this.bothEdgesMap.get(oldSource).delete(edge);\n        this.outEdgesMap.get(newSource).add(edge);\n        this.bothEdgesMap.get(newSource).add(edge);\n        edge.source = source;\n        this.batch(() => {\n            this.changes.push({\n                type: 'EdgeUpdated',\n                id,\n                propertyName: 'source',\n                oldValue: oldSource,\n                newValue: newSource,\n            });\n        });\n    }\n    /**\n     * Change the target of an edge. The target must be found in current graph.\n     * @group EdgeMethods\n     */\n    updateEdgeTarget(id, target) {\n        const edge = this.getEdge(id);\n        this.checkNodeExistence(target);\n        const oldTarget = edge.target;\n        const newTarget = target;\n        this.inEdgesMap.get(oldTarget).delete(edge);\n        this.bothEdgesMap.get(oldTarget).delete(edge);\n        this.inEdgesMap.get(newTarget).add(edge);\n        this.bothEdgesMap.get(newTarget).add(edge);\n        edge.target = target;\n        this.batch(() => {\n            this.changes.push({\n                type: 'EdgeUpdated',\n                id,\n                propertyName: 'target',\n                oldValue: oldTarget,\n                newValue: newTarget,\n            });\n        });\n    }\n    updateEdgeDataProperty(id, propertyName, value) {\n        const edge = this.getEdge(id);\n        this.batch(() => {\n            const oldValue = edge.data[propertyName];\n            const newValue = value;\n            edge.data[propertyName] = newValue;\n            this.changes.push({\n                type: 'EdgeDataUpdated',\n                id,\n                propertyName,\n                oldValue,\n                newValue,\n            });\n        });\n    }\n    updateEdgeData(...args) {\n        const id = args[0];\n        const edge = this.getEdge(id);\n        if (typeof args[1] === 'string') {\n            // id, propertyName, value\n            this.updateEdgeDataProperty(id, args[1], args[2]);\n            return;\n        }\n        let data;\n        if (typeof args[1] === 'function') {\n            // id, update\n            const update = args[1];\n            data = update(edge.data);\n        }\n        else if (typeof args[1] === 'object') {\n            // id, data\n            data = args[1];\n        }\n        this.batch(() => {\n            const oldValue = edge.data;\n            const newValue = data;\n            edge.data = data;\n            this.changes.push({\n                type: 'EdgeDataUpdated',\n                id,\n                oldValue,\n                newValue,\n            });\n        });\n    }\n    /**\n     * @group EdgeMethods\n     */\n    mergeEdgeData(id, patch) {\n        this.batch(() => {\n            Object.entries(patch).forEach(([propertyName, value]) => {\n                this.updateEdgeDataProperty(id, propertyName, value);\n            });\n        });\n    }\n    // ================= Tree =================\n    checkTreeExistence(treeKey) {\n        if (!this.hasTreeStructure(treeKey)) {\n            throw new Error('Tree structure not found for treeKey: ' + treeKey);\n        }\n    }\n    hasTreeStructure(treeKey) {\n        return this.treeIndices.has(treeKey);\n    }\n    /**\n     * Attach a new tree structure representing the hierarchy of all nodes in the graph.\n     * @param treeKey A unique key of the tree structure. You can attach multiple tree structures with different keys.\n     *\n     * ```ts\n     * const graph = new Graph({\n     *   nodes: [{ id: 1 }, { id: 2 }, { id: 3 }],\n     * });\n     * graph.attachTreeStructure('Inheritance');\n     * graph.setParent(2, 1, 'Inheritance');\n     * graph.setParent(3, 1, 'Inheritance');\n     * graph.getRoots('Inheritance'); // [1]\n     * graph.getChildren(1, 'Inheritance'); // [2,3]\n     * ```\n     * @group TreeMethods\n     */\n    attachTreeStructure(treeKey) {\n        if (this.treeIndices.has(treeKey)) {\n            // Already attached.\n            return;\n        }\n        this.treeIndices.set(treeKey, {\n            parentMap: new Map(),\n            childrenMap: new Map(),\n        });\n        this.batch(() => {\n            this.changes.push({\n                type: 'TreeStructureAttached',\n                treeKey,\n            });\n        });\n    }\n    /**\n     * Detach the tree structure of the given tree key from the graph.\n     *\n     * ```ts\n     * graph.detachTreeStructure('Inheritance');\n     * graph.getRoots('Inheritance'); // Error!\n     * ```\n     * @group TreeMethods\n     */\n    detachTreeStructure(treeKey) {\n        this.checkTreeExistence(treeKey);\n        this.treeIndices.delete(treeKey);\n        this.batch(() => {\n            this.changes.push({\n                type: 'TreeStructureDetached',\n                treeKey,\n            });\n        });\n    }\n    /**\n     * Traverse the given tree data, add each node into the graph, then attach the tree structure.\n     *\n     * ```ts\n     * graph.addTree({\n     *   id: 1,\n     *   children: [\n     *     { id: 2 },\n     *     { id: 3 },\n     *   ],\n     * }, 'Inheritance');\n     * graph.getRoots('Inheritance'); // [1]\n     * graph.getChildren(1, 'Inheritance'); // [2, 3]\n     * graph.getAllNodes(); // [1, 2, 3]\n     * graph.getAllEdges(); // []\n     * ```\n     * @group TreeMethods\n     */\n    addTree(tree, treeKey) {\n        this.batch(() => {\n            this.attachTreeStructure(treeKey);\n            // Add Nodes\n            const nodes = [];\n            const stack = Array.isArray(tree) ? tree : [tree];\n            while (stack.length) {\n                const node = stack.shift();\n                nodes.push(node);\n                if (node.children) {\n                    stack.push(...node.children);\n                }\n            }\n            this.addNodes(nodes);\n            // Set parent for each child node.\n            nodes.forEach((parent) => {\n                parent.children?.forEach((child) => {\n                    this.setParent(child.id, parent.id, treeKey);\n                });\n            });\n        });\n    }\n    /**\n     * Get the root nodes of an attached tree structure.\n     *\n     * Consider a graph with the following tree structure attached:\n     * ```\n     * Tree structure:\n     *    O     3\n     *   / \\    |\n     *  1   2   4\n     * ```\n     * `graph.getRoots()` takes all nodes without a parent, therefore [0, 3] was returned.\n     *\n     * Newly added nodes are also unparented. So they are counted as roots.\n     * ```ts\n     * graph.addNode({ id: 5 });\n     * graph.getRoots(); // [0, 3, 5]\n     * ```\n     *\n     * Here is how the tree structure looks like:\n     * ```\n     * Tree structure:\n     *    O     3  5\n     *   / \\    |\n     *  1   2   4\n     * ```\n     *\n     * By setting a parent, a root node no more be a root.\n     * ```ts\n     * graph.setParent(5, 2);\n     * graph.getRoots(); // [0, 3]\n     * ```\n     *\n     * The tree structure now becomes:\n     * ```\n     * Tree structure:\n     *    O     3\n     *   / \\    |\n     *  1   2   4\n     *      |\n     *      5\n     * ```\n     *\n     * Removing a node forces its children to be unparented, or roots.\n     * ```ts\n     * graph.removeNode(0);\n     * graph.getRoots(); // [1, 2, 3]\n     * ```\n     *\n     * You might draw the the structure as follow:\n     * ```\n     * Tree structure:\n     *  1   2  3\n     *      |  |\n     *      5  4\n     * ```\n     * @group TreeMethods\n     */\n    getRoots(treeKey) {\n        this.checkTreeExistence(treeKey);\n        return this.getAllNodes().filter((node) => !this.getParent(node.id, treeKey));\n    }\n    /**\n     * Given a node ID and an optional tree key, get the children of the node in the specified tree structure.\n     * @group TreeMethods\n     */\n    getChildren(id, treeKey) {\n        this.checkNodeExistence(id);\n        this.checkTreeExistence(treeKey);\n        const tree = this.treeIndices.get(treeKey);\n        const children = tree.childrenMap.get(id);\n        return Array.from(children || []);\n    }\n    /**\n     * Given a node ID and an optional tree key, get the parent of the node in the specified tree structure.\n     * If the given node is one of the tree roots, this returns null.\n     * @group TreeMethods\n     */\n    getParent(id, treeKey) {\n        this.checkNodeExistence(id);\n        this.checkTreeExistence(treeKey);\n        const tree = this.treeIndices.get(treeKey);\n        return tree.parentMap.get(id) || null;\n    }\n    /**\n     * Returns an array of all the ancestor nodes, staring from the parent to the root.\n     */\n    getAncestors(id, treeKey) {\n        const ancestors = [];\n        let current = this.getNode(id);\n        let parent;\n        // eslint-disable-next-line no-cond-assign\n        while ((parent = this.getParent(current.id, treeKey))) {\n            ancestors.push(parent);\n            current = parent;\n        }\n        return ancestors;\n    }\n    /**\n     * Set node parent. If this operation causes a circle, it fails with an error.\n     * @param id - ID of the child node.\n     * @param parent - ID of the parent node. If it is undefined or null, means unset parent for node with id.\n     * @param treeKey - Which tree structure the relation is applied to.\n     * @group TreeMethods\n     */\n    setParent(id, parent, treeKey) {\n        this.checkTreeExistence(treeKey);\n        const tree = this.treeIndices.get(treeKey);\n        if (!tree)\n            return;\n        const node = this.getNode(id);\n        const oldParent = tree.parentMap.get(id);\n        // Same parent id as old one, skip\n        if (oldParent?.id === parent)\n            return;\n        // New parent is undefined or null, unset parent for the node\n        if (parent === undefined || parent === null) {\n            if (oldParent) {\n                tree.childrenMap.get(oldParent.id)?.delete(node);\n            }\n            tree.parentMap.delete(id);\n            return;\n        }\n        const newParent = this.getNode(parent);\n        // Set parent\n        tree.parentMap.set(id, newParent);\n        // Set children\n        if (oldParent) {\n            tree.childrenMap.get(oldParent.id)?.delete(node);\n        }\n        let children = tree.childrenMap.get(newParent.id);\n        if (!children) {\n            children = new Set();\n            tree.childrenMap.set(newParent.id, children);\n        }\n        children.add(node);\n        this.batch(() => {\n            this.changes.push({\n                type: 'TreeStructureChanged',\n                treeKey,\n                nodeId: id,\n                oldParentId: oldParent?.id,\n                newParentId: newParent.id,\n            });\n        });\n    }\n    dfsTree(id, fn, treeKey) {\n        const navigator = (nodeId) => this.getChildren(nodeId, treeKey);\n        return doDFS(this.getNode(id), new Set(), fn, navigator);\n    }\n    bfsTree(id, fn, treeKey) {\n        const navigator = (nodeId) => this.getChildren(nodeId, treeKey);\n        return doBFS([this.getNode(id)], new Set(), fn, navigator);\n    }\n    // ================= Graph =================\n    /**\n     * Get all nodes in the graph as an array.\n     */\n    getAllNodes() {\n        return Array.from(this.nodeMap.values());\n    }\n    /**\n     * Get all edges in the graph as an array.\n     */\n    getAllEdges() {\n        return Array.from(this.edgeMap.values());\n    }\n    bfs(id, fn, direction = 'out') {\n        const navigator = {\n            in: this.getPredecessors.bind(this),\n            out: this.getSuccessors.bind(this),\n            both: this.getNeighbors.bind(this),\n        }[direction];\n        return doBFS([this.getNode(id)], new Set(), fn, navigator);\n    }\n    dfs(id, fn, direction = 'out') {\n        const navigator = {\n            in: this.getPredecessors.bind(this),\n            out: this.getSuccessors.bind(this),\n            both: this.getNeighbors.bind(this),\n        }[direction];\n        return doDFS(this.getNode(id), new Set(), fn, navigator);\n    }\n    clone() {\n        // Make a shallow copy of nodes and edges.\n        const newNodes = this.getAllNodes().map((oldNode) => {\n            return { ...oldNode, data: { ...oldNode.data } };\n        });\n        const newEdges = this.getAllEdges().map((oldEdge) => {\n            return { ...oldEdge, data: { ...oldEdge.data } };\n        });\n        // Create a new graph with shallow copied nodes and edges.\n        const newGraph = new Graph({\n            nodes: newNodes,\n            edges: newEdges,\n        });\n        // Add tree indices.\n        this.treeIndices.forEach(({ parentMap: oldParentMap, childrenMap: oldChildrenMap }, treeKey) => {\n            const parentMap = new Map();\n            oldParentMap.forEach((parent, key) => {\n                parentMap.set(key, newGraph.getNode(parent.id));\n            });\n            const childrenMap = new Map();\n            oldChildrenMap.forEach((children, key) => {\n                childrenMap.set(key, new Set(Array.from(children).map((n) => newGraph.getNode(n.id))));\n            });\n            newGraph.treeIndices.set(treeKey, {\n                parentMap: parentMap,\n                childrenMap: childrenMap,\n            });\n        });\n        return newGraph;\n    }\n    toJSON() {\n        return JSON.stringify({\n            nodes: this.getAllNodes(),\n            edges: this.getAllEdges(),\n            // FIXME: And tree structures?\n        });\n    }\n    createView(options) {\n        return new GraphView({\n            graph: this,\n            ...options,\n        });\n    }\n}\n//# sourceMappingURL=graph.js.map"],"names":["Graph","EventEmitter","options","__publicField","fn","changes","event","mergedChanges","change","isNewlyAdded","pastChange","sameId","index","existingChange","id","firstNodeId","secondNodeId","neighbor","node","direction","inEdges","outEdges","bothEdges","targets","edge","sources","predecessors","successors","tree","nodes","_a","child","parent","_b","idList","propertyName","value","oldValue","newValue","patch","args","data","update","bothEdgesOfSource","bothEdgesOfTarget","edges","source","oldSource","newSource","target","oldTarget","newTarget","treeKey","stack","children","ancestors","current","oldParent","newParent","navigator","nodeId","doDFS","doBFS","newNodes","oldNode","newEdges","oldEdge","newGraph","oldParentMap","oldChildrenMap","parentMap","key","childrenMap","n","GraphView"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/graphlib/esm/graphView.js

@@ -0,0 +1,194 @@
+var n = Object.defineProperty;
+var c = (h, e, t) => e in h ? n(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
+var a = (h, e, t) => c(h, typeof e != "symbol" ? e + "" : e, t);
+import { doBFS as u, doDFS as p } from "./utils/traverse.js";
+const o = () => !0;
+class N {
+  constructor(e) {
+    a(this, "graph");
+    a(this, "nodeFilter");
+    a(this, "edgeFilter");
+    // caches
+    a(this, "cacheEnabled");
+    a(this, "inEdgesMap", /* @__PURE__ */ new Map());
+    a(this, "outEdgesMap", /* @__PURE__ */ new Map());
+    a(this, "bothEdgesMap", /* @__PURE__ */ new Map());
+    a(this, "allNodesMap", /* @__PURE__ */ new Map());
+    a(this, "allEdgesMap", /* @__PURE__ */ new Map());
+    /**
+     * Clear all cache data. Therefore `getAllNodes()` will return `[]`.
+     * If you want to disable caching, use `graphView.cacheEnabled = false` instead.
+     */
+    a(this, "clearCache", () => {
+      this.inEdgesMap.clear(), this.outEdgesMap.clear(), this.bothEdgesMap.clear(), this.allNodesMap.clear(), this.allEdgesMap.clear();
+    });
+    /**
+     * Fully refresh all cache data to the current graph state.
+     */
+    a(this, "refreshCache", () => {
+      this.clearCache(), this.updateCache(this.graph.getAllNodes().map((e) => e.id));
+    });
+    /**
+     * Instead of a fully refreshment, this method partially update the cache data by specifying
+     * involved(added, removed, updated) nodes. It's more efficient when handling small changes
+     * on a large graph.
+     */
+    a(this, "updateCache", (e) => {
+      const t = /* @__PURE__ */ new Set();
+      e.forEach((s) => {
+        const r = this.bothEdgesMap.get(s);
+        if (r && r.forEach((d) => t.add(d.id)), !this.hasNode(s))
+          this.inEdgesMap.delete(s), this.outEdgesMap.delete(s), this.bothEdgesMap.delete(s), this.allNodesMap.delete(s);
+        else {
+          const d = this.graph.getRelatedEdges(s, "in").filter(this.edgeFilter), i = this.graph.getRelatedEdges(s, "out").filter(this.edgeFilter), g = Array.from(/* @__PURE__ */ new Set([...d, ...i]));
+          g.forEach((l) => t.add(l.id)), this.inEdgesMap.set(s, d), this.outEdgesMap.set(s, i), this.bothEdgesMap.set(s, g), this.allNodesMap.set(s, this.graph.getNode(s));
+        }
+      }), t.forEach((s) => {
+        this.hasEdge(s) ? this.allEdgesMap.set(s, this.graph.getEdge(s)) : this.allEdgesMap.delete(s);
+      });
+    });
+    a(this, "handleGraphChanged", (e) => {
+      const t = /* @__PURE__ */ new Set();
+      e.changes.forEach((s) => {
+        switch (s.type) {
+          case "NodeAdded":
+            t.add(s.value.id);
+            break;
+          case "NodeDataUpdated":
+            t.add(s.id);
+            break;
+          case "EdgeAdded":
+            t.add(s.value.source), t.add(s.value.target);
+            break;
+          case "EdgeUpdated":
+            (s.propertyName === "source" || s.propertyName === "target") && (t.add(s.oldValue), t.add(s.newValue));
+            break;
+          case "EdgeDataUpdated":
+            if (e.graph.hasEdge(s.id)) {
+              const r = e.graph.getEdge(s.id);
+              t.add(r.source), t.add(r.target);
+            }
+            break;
+          case "EdgeRemoved":
+            t.add(s.value.source), t.add(s.value.target);
+            break;
+          case "NodeRemoved":
+            t.add(s.value.id);
+            break;
+        }
+      }), this.updateCache(t);
+    });
+    this.graph = e.graph;
+    const t = e.nodeFilter || o, s = e.edgeFilter || o;
+    this.nodeFilter = t, this.edgeFilter = (r) => {
+      const { source: d, target: i } = this.graph.getEdgeDetail(r.id);
+      return !t(d) || !t(i) ? !1 : s(r, d, i);
+    }, e.cache === "auto" ? (this.cacheEnabled = !0, this.startAutoCache()) : e.cache === "manual" ? this.cacheEnabled = !0 : this.cacheEnabled = !1;
+  }
+  startAutoCache() {
+    this.refreshCache(), this.graph.on("changed", this.handleGraphChanged);
+  }
+  stopAutoCache() {
+    this.graph.off("changed", this.handleGraphChanged);
+  }
+  // ================= Node =================
+  checkNodeExistence(e) {
+    this.getNode(e);
+  }
+  hasNode(e) {
+    if (!this.graph.hasNode(e))
+      return !1;
+    const t = this.graph.getNode(e);
+    return this.nodeFilter(t);
+  }
+  areNeighbors(e, t) {
+    return this.checkNodeExistence(e), this.getNeighbors(t).some((s) => s.id === e);
+  }
+  getNode(e) {
+    const t = this.graph.getNode(e);
+    if (!this.nodeFilter(t))
+      throw new Error("Node not found for id: " + e);
+    return t;
+  }
+  getRelatedEdges(e, t) {
+    return this.checkNodeExistence(e), this.cacheEnabled ? t === "in" ? this.inEdgesMap.get(e) : t === "out" ? this.outEdgesMap.get(e) : this.bothEdgesMap.get(e) : this.graph.getRelatedEdges(e, t).filter(this.edgeFilter);
+  }
+  getDegree(e, t) {
+    return this.getRelatedEdges(e, t).length;
+  }
+  getSuccessors(e) {
+    const s = this.getRelatedEdges(e, "out").map((r) => this.getNode(r.target));
+    return Array.from(new Set(s));
+  }
+  getPredecessors(e) {
+    const s = this.getRelatedEdges(e, "in").map((r) => this.getNode(r.source));
+    return Array.from(new Set(s));
+  }
+  getNeighbors(e) {
+    const t = this.getPredecessors(e), s = this.getSuccessors(e);
+    return Array.from(/* @__PURE__ */ new Set([...t, ...s]));
+  }
+  // ================= Edge =================
+  hasEdge(e) {
+    if (!this.graph.hasEdge(e))
+      return !1;
+    const t = this.graph.getEdge(e);
+    return this.edgeFilter(t);
+  }
+  getEdge(e) {
+    const t = this.graph.getEdge(e);
+    if (!this.edgeFilter(t))
+      throw new Error("Edge not found for id: " + e);
+    return t;
+  }
+  getEdgeDetail(e) {
+    const t = this.getEdge(e);
+    return {
+      edge: t,
+      source: this.getNode(t.source),
+      target: this.getNode(t.target)
+    };
+  }
+  // ================= Tree =================
+  hasTreeStructure(e) {
+    return this.graph.hasTreeStructure(e);
+  }
+  getRoots(e) {
+    return this.graph.getRoots(e).filter(this.nodeFilter);
+  }
+  getChildren(e, t) {
+    return this.checkNodeExistence(e), this.graph.getChildren(e, t).filter(this.nodeFilter);
+  }
+  getParent(e, t) {
+    this.checkNodeExistence(e);
+    const s = this.graph.getParent(e, t);
+    return !s || !this.nodeFilter(s) ? null : s;
+  }
+  // ================= Graph =================
+  getAllNodes() {
+    return this.cacheEnabled ? Array.from(this.allNodesMap.values()) : this.graph.getAllNodes().filter(this.nodeFilter);
+  }
+  getAllEdges() {
+    return this.cacheEnabled ? Array.from(this.allEdgesMap.values()) : this.graph.getAllEdges().filter(this.edgeFilter);
+  }
+  bfs(e, t, s = "out") {
+    const r = {
+      in: this.getPredecessors.bind(this),
+      out: this.getSuccessors.bind(this),
+      both: this.getNeighbors.bind(this)
+    }[s];
+    u([this.getNode(e)], /* @__PURE__ */ new Set(), t, r);
+  }
+  dfs(e, t, s = "out") {
+    const r = {
+      in: this.getPredecessors.bind(this),
+      out: this.getSuccessors.bind(this),
+      both: this.getNeighbors.bind(this)
+    }[s];
+    p(this.getNode(e), /* @__PURE__ */ new Set(), t, r);
+  }
+}
+export {
+  N as GraphView
+};
+//# sourceMappingURL=graphView.js.map

package/dist/node_modules/@antv/graphlib/esm/graphView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphView.js","sources":["../../../../../node_modules/@antv/graphlib/esm/graphView.js"],"sourcesContent":["import { doBFS, doDFS } from './utils/traverse';\nconst defaultFilter = () => true;\nexport class GraphView {\n    graph;\n    nodeFilter;\n    edgeFilter;\n    // caches\n    cacheEnabled;\n    inEdgesMap = new Map();\n    outEdgesMap = new Map();\n    bothEdgesMap = new Map();\n    allNodesMap = new Map();\n    allEdgesMap = new Map();\n    constructor(options) {\n        this.graph = options.graph;\n        const nodeFilter = options.nodeFilter || defaultFilter;\n        const edgeFilter = options.edgeFilter || defaultFilter;\n        this.nodeFilter = nodeFilter;\n        this.edgeFilter = (edge) => {\n            const { source, target } = this.graph.getEdgeDetail(edge.id);\n            if (!nodeFilter(source) || !nodeFilter(target)) {\n                return false;\n            }\n            return edgeFilter(edge, source, target);\n        };\n        if (options.cache === 'auto') {\n            this.cacheEnabled = true;\n            this.startAutoCache();\n        }\n        else if (options.cache === 'manual') {\n            this.cacheEnabled = true;\n        }\n        else {\n            this.cacheEnabled = false;\n        }\n    }\n    /**\n     * Clear all cache data. Therefore `getAllNodes()` will return `[]`.\n     * If you want to disable caching, use `graphView.cacheEnabled = false` instead.\n     */\n    clearCache = () => {\n        this.inEdgesMap.clear();\n        this.outEdgesMap.clear();\n        this.bothEdgesMap.clear();\n        this.allNodesMap.clear();\n        this.allEdgesMap.clear();\n    };\n    /**\n     * Fully refresh all cache data to the current graph state.\n     */\n    refreshCache = () => {\n        this.clearCache();\n        this.updateCache(this.graph.getAllNodes().map((node) => node.id));\n    };\n    /**\n     * Instead of a fully refreshment, this method partially update the cache data by specifying\n     * involved(added, removed, updated) nodes. It's more efficient when handling small changes\n     * on a large graph.\n     */\n    updateCache = (involvedNodeIds) => {\n        const involvedEdgeIds = new Set();\n        involvedNodeIds.forEach((id) => {\n            // Collect all involved old edges.\n            const oldEdgesSet = this.bothEdgesMap.get(id);\n            if (oldEdgesSet) {\n                oldEdgesSet.forEach((edge) => involvedEdgeIds.add(edge.id));\n            }\n            if (!this.hasNode(id)) {\n                // When an involved node becomes unvisitable:\n                // 1. Delete its related edges cache.\n                this.inEdgesMap.delete(id);\n                this.outEdgesMap.delete(id);\n                this.bothEdgesMap.delete(id);\n                // 2. Delete it from the allNodesMap.\n                this.allNodesMap.delete(id);\n            }\n            else {\n                // When an involved node becomes or stays visitable:\n                // 1. Collect its new edges.\n                const inEdges = this.graph\n                    .getRelatedEdges(id, 'in')\n                    .filter(this.edgeFilter);\n                const outEdges = this.graph\n                    .getRelatedEdges(id, 'out')\n                    .filter(this.edgeFilter);\n                const bothEdges = Array.from(new Set([...inEdges, ...outEdges]));\n                bothEdges.forEach((edge) => involvedEdgeIds.add(edge.id));\n                // 2. Update its related edges cache.\n                this.inEdgesMap.set(id, inEdges);\n                this.outEdgesMap.set(id, outEdges);\n                this.bothEdgesMap.set(id, bothEdges);\n                // 3. Add to allNodesMap.\n                this.allNodesMap.set(id, this.graph.getNode(id));\n            }\n        });\n        // Update allEdgesMap.\n        involvedEdgeIds.forEach((id) => {\n            if (this.hasEdge(id)) {\n                this.allEdgesMap.set(id, this.graph.getEdge(id));\n            }\n            else {\n                this.allEdgesMap.delete(id);\n            }\n        });\n    };\n    startAutoCache() {\n        this.refreshCache();\n        this.graph.on('changed', this.handleGraphChanged);\n    }\n    stopAutoCache() {\n        this.graph.off('changed', this.handleGraphChanged);\n    }\n    handleGraphChanged = (event) => {\n        // Collect all involved nodes.\n        const involvedNodeIds = new Set();\n        event.changes.forEach((change) => {\n            switch (change.type) {\n                case 'NodeAdded':\n                    involvedNodeIds.add(change.value.id);\n                    break;\n                case 'NodeDataUpdated':\n                    involvedNodeIds.add(change.id);\n                    break;\n                case 'EdgeAdded':\n                    involvedNodeIds.add(change.value.source);\n                    involvedNodeIds.add(change.value.target);\n                    break;\n                case 'EdgeUpdated':\n                    if (change.propertyName === 'source' ||\n                        change.propertyName === 'target') {\n                        involvedNodeIds.add(change.oldValue);\n                        involvedNodeIds.add(change.newValue);\n                    }\n                    break;\n                case 'EdgeDataUpdated':\n                    if (event.graph.hasEdge(change.id)) {\n                        const edge = event.graph.getEdge(change.id);\n                        involvedNodeIds.add(edge.source);\n                        involvedNodeIds.add(edge.target);\n                    }\n                    break;\n                case 'EdgeRemoved':\n                    involvedNodeIds.add(change.value.source);\n                    involvedNodeIds.add(change.value.target);\n                    break;\n                case 'NodeRemoved':\n                    involvedNodeIds.add(change.value.id);\n                    break;\n                default:\n                    break;\n            }\n        });\n        // Update their caches.\n        this.updateCache(involvedNodeIds);\n    };\n    // ================= Node =================\n    checkNodeExistence(id) {\n        this.getNode(id);\n    }\n    hasNode(id) {\n        if (!this.graph.hasNode(id))\n            return false;\n        const node = this.graph.getNode(id);\n        return this.nodeFilter(node);\n    }\n    areNeighbors(firstNodeId, secondNodeId) {\n        this.checkNodeExistence(firstNodeId);\n        return this.getNeighbors(secondNodeId).some((neighbor) => neighbor.id === firstNodeId);\n    }\n    getNode(id) {\n        const node = this.graph.getNode(id);\n        if (!this.nodeFilter(node)) {\n            throw new Error('Node not found for id: ' + id);\n        }\n        return node;\n    }\n    getRelatedEdges(id, direction) {\n        this.checkNodeExistence(id);\n        if (this.cacheEnabled) {\n            if (direction === 'in') {\n                return this.inEdgesMap.get(id);\n            }\n            else if (direction === 'out') {\n                return this.outEdgesMap.get(id);\n            }\n            else {\n                return this.bothEdgesMap.get(id);\n            }\n        }\n        const edges = this.graph.getRelatedEdges(id, direction);\n        return edges.filter(this.edgeFilter);\n    }\n    getDegree(id, direction) {\n        return this.getRelatedEdges(id, direction).length;\n    }\n    getSuccessors(id) {\n        const outEdges = this.getRelatedEdges(id, 'out');\n        const targets = outEdges.map((edge) => this.getNode(edge.target));\n        return Array.from(new Set(targets));\n    }\n    getPredecessors(id) {\n        const inEdges = this.getRelatedEdges(id, 'in');\n        const sources = inEdges.map((edge) => this.getNode(edge.source));\n        return Array.from(new Set(sources));\n    }\n    getNeighbors(id) {\n        const predecessors = this.getPredecessors(id);\n        const successors = this.getSuccessors(id);\n        return Array.from(new Set([...predecessors, ...successors]));\n    }\n    // ================= Edge =================\n    hasEdge(id) {\n        if (!this.graph.hasEdge(id))\n            return false;\n        const edge = this.graph.getEdge(id);\n        return this.edgeFilter(edge);\n    }\n    getEdge(id) {\n        const edge = this.graph.getEdge(id);\n        if (!this.edgeFilter(edge)) {\n            throw new Error('Edge not found for id: ' + id);\n        }\n        return edge;\n    }\n    getEdgeDetail(id) {\n        const edge = this.getEdge(id);\n        return {\n            edge,\n            source: this.getNode(edge.source),\n            target: this.getNode(edge.target),\n        };\n    }\n    // ================= Tree =================\n    hasTreeStructure(treeKey) {\n        return this.graph.hasTreeStructure(treeKey);\n    }\n    getRoots(treeKey) {\n        return this.graph.getRoots(treeKey).filter(this.nodeFilter);\n    }\n    getChildren(id, treeKey) {\n        this.checkNodeExistence(id);\n        return this.graph.getChildren(id, treeKey).filter(this.nodeFilter);\n    }\n    getParent(id, treeKey) {\n        this.checkNodeExistence(id);\n        const parent = this.graph.getParent(id, treeKey);\n        if (!parent || !this.nodeFilter(parent))\n            return null;\n        return parent;\n    }\n    // ================= Graph =================\n    getAllNodes() {\n        if (this.cacheEnabled) {\n            return Array.from(this.allNodesMap.values());\n        }\n        return this.graph.getAllNodes().filter(this.nodeFilter);\n    }\n    getAllEdges() {\n        if (this.cacheEnabled) {\n            return Array.from(this.allEdgesMap.values());\n        }\n        return this.graph.getAllEdges().filter(this.edgeFilter);\n    }\n    bfs(id, fn, direction = 'out') {\n        const navigator = {\n            in: this.getPredecessors.bind(this),\n            out: this.getSuccessors.bind(this),\n            both: this.getNeighbors.bind(this),\n        }[direction];\n        doBFS([this.getNode(id)], new Set(), fn, navigator);\n    }\n    dfs(id, fn, direction = 'out') {\n        const navigator = {\n            in: this.getPredecessors.bind(this),\n            out: this.getSuccessors.bind(this),\n            both: this.getNeighbors.bind(this),\n        }[direction];\n        doDFS(this.getNode(id), new Set(), fn, navigator);\n    }\n}\n//# sourceMappingURL=graphView.js.map"],"names":["defaultFilter","GraphView","options","__publicField","node","involvedNodeIds","involvedEdgeIds","id","oldEdgesSet","edge","inEdges","outEdges","bothEdges","event","change","nodeFilter","edgeFilter","source","target","firstNodeId","secondNodeId","neighbor","direction","targets","sources","predecessors","successors","treeKey","parent","fn","navigator","doBFS","doDFS"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/graphlib/esm/utils/traverse.js

@@ -0,0 +1,25 @@
+function h(r, t, o, f) {
+  for (; r.length; ) {
+    const a = r.shift();
+    if (o(a))
+      return !0;
+    t.add(a.id), f(a.id).forEach((n) => {
+      t.has(n.id) || (t.add(n.id), r.push(n));
+    });
+  }
+  return !1;
+}
+function c(r, t, o, f) {
+  if (o(r))
+    return !0;
+  t.add(r.id);
+  for (const d of f(r.id))
+    if (!t.has(d.id) && c(d, t, o, f))
+      return !0;
+  return !1;
+}
+export {
+  h as doBFS,
+  c as doDFS
+};
+//# sourceMappingURL=traverse.js.map

package/dist/node_modules/@antv/graphlib/esm/utils/traverse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.js","sources":["../../../../../../node_modules/@antv/graphlib/esm/utils/traverse.js"],"sourcesContent":["export function doBFS(queue, visited, fn, navigator) {\n    while (queue.length) {\n        const node = queue.shift();\n        const abort = fn(node);\n        if (abort) {\n            return true;\n        }\n        visited.add(node.id);\n        navigator(node.id).forEach((n) => {\n            if (!visited.has(n.id)) {\n                visited.add(n.id);\n                queue.push(n);\n            }\n        });\n    }\n    return false;\n}\nexport function doDFS(node, visited, fn, navigator) {\n    const abort = fn(node);\n    if (abort) {\n        return true;\n    }\n    visited.add(node.id);\n    for (const n of navigator(node.id)) {\n        if (!visited.has(n.id)) {\n            if (doDFS(n, visited, fn, navigator)) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n//# sourceMappingURL=traverse.js.map"],"names":["doBFS","queue","visited","fn","navigator","node","doDFS","n"],"mappings":"AAAO,SAASA,EAAMC,GAAOC,GAASC,GAAIC,GAAW;AACjD,SAAOH,EAAM,UAAQ;AACjB,UAAMI,IAAOJ,EAAM,MAAK;AAExB,QADcE,EAAGE,CAAI;AAEjB,aAAO;AAEX,IAAAH,EAAQ,IAAIG,EAAK,EAAE,GACnBD,EAAUC,EAAK,EAAE,EAAE,QAAQ,CAAC,MAAM;AAC9B,MAAKH,EAAQ,IAAI,EAAE,EAAE,MACjBA,EAAQ,IAAI,EAAE,EAAE,GAChBD,EAAM,KAAK,CAAC;AAAA,IAEpB,CAAC;AAAA,EACL;AACA,SAAO;AACX;AACO,SAASK,EAAMD,GAAMH,GAASC,GAAIC,GAAW;AAEhD,MADcD,EAAGE,CAAI;AAEjB,WAAO;AAEX,EAAAH,EAAQ,IAAIG,EAAK,EAAE;AACnB,aAAWE,KAAKH,EAAUC,EAAK,EAAE;AAC7B,QAAI,CAACH,EAAQ,IAAIK,EAAE,EAAE,KACbD,EAAMC,GAAGL,GAASC,GAAIC,CAAS;AAC/B,aAAO;AAInB,SAAO;AACX;","x_google_ignoreList":[0]}