@lerna/publish
Version:
Publish packages in the current project
115 lines (114 loc) • 3.54 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var cyclic_package_graph_node_exports = {};
__export(cyclic_package_graph_node_exports, {
CyclicPackageGraphNode: () => CyclicPackageGraphNode
});
module.exports = __toCommonJS(cyclic_package_graph_node_exports);
let lastCollapsedNodeId = 0;
class CyclicPackageGraphNode extends Map {
name;
localDependencies;
localDependents;
constructor() {
super();
this.name = `(cycle) ${lastCollapsedNodeId += 1}`;
this.localDependencies = /* @__PURE__ */ new Map();
this.localDependents = /* @__PURE__ */ new Map();
}
// eslint-disable-next-line class-methods-use-this
get isCycle() {
return true;
}
/**
* @returns A representation of a cycle, like like `A -> B -> C -> A`.
*/
toString() {
const parts = Array.from(
this,
([key, node]) => (
// TODO: refactor to address type issues
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
node.isCycle ? `(nested cycle: ${node.toString()})` : key
)
);
parts.push(parts[0]);
return parts.reverse().join(" -> ");
}
/**
* Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
*/
flatten() {
const result = [];
for (const node of this.values()) {
if (node.isCycle) {
result.push(...node.flatten());
} else {
result.push(node);
}
}
return result;
}
/**
* Checks if a given node is contained in this cycle (or in a nested one)
*
* @param name The name of the package to search in this cycle
*/
contains(name) {
for (const [currentName, currentNode] of this) {
if (currentNode.isCycle) {
if (currentNode.contains(name)) {
return true;
}
} else if (currentName === name) {
return true;
}
}
return false;
}
/**
* Adds a graph node, or a nested cycle, to this group.
*/
insert(node) {
this.set(node.name, node);
this.unlink(node);
for (const [dependencyName, dependencyNode] of node.localDependencies) {
if (!this.contains(dependencyName)) {
this.localDependencies.set(dependencyName, dependencyNode);
}
}
for (const [dependentName, dependentNode] of node.localDependents) {
if (!this.contains(dependentName)) {
this.localDependents.set(dependentName, dependentNode);
}
}
}
/**
* Remove pointers to candidate node from internal collections.
* @param candidateNode instance to unlink
*/
unlink(candidateNode) {
this.localDependencies.delete(candidateNode.name);
this.localDependents.delete(candidateNode.name);
}
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
CyclicPackageGraphNode
});