@cdxgen/cdxgen 0.0.1 → 13.0.1

package/lib/third-party/arborist/lib/inventory.js

@@ -0,0 +1,138 @@
+import debug from "./debug.js";
+
+// a class to manage an inventory and set of indexes of a set of objects based on specific fields.
+const { hasOwnProperty: hasOwn } = Object.prototype;
+
+const keys = ["name", "license", "funding", "realpath", "packageName"];
+class Inventory extends Map {
+  #index;
+
+  constructor() {
+    super();
+    this.#index = new Map();
+    for (const key of keys) {
+      this.#index.set(key, new Map());
+    }
+  }
+
+  // XXX where is this used?
+  get primaryKey() {
+    return "location";
+  }
+
+  // XXX where is this used?
+  get indexes() {
+    return [...keys];
+  }
+
+  *filter(fn) {
+    for (const node of this.values()) {
+      if (fn(node)) {
+        yield node;
+      }
+    }
+  }
+
+  add(node) {
+    const root = super.get("");
+    if (root && node.root !== root && node.root !== root.root) {
+      debug(() => {
+        throw Object.assign(new Error("adding external node to inventory"), {
+          root: root.path,
+          node: node.path,
+          nodeRoot: node.root.path,
+        });
+      });
+      return;
+    }
+
+    const current = super.get(node.location);
+    if (current) {
+      if (current === node) {
+        return;
+      }
+      this.delete(current);
+    }
+    super.set(node.location, node);
+    for (const [key, map] of this.#index.entries()) {
+      let val;
+      if (hasOwn.call(node, key)) {
+        // if the node has the value, use it even if it's false
+        val = node[key];
+      } else if (key === "license" && node.package) {
+        // handling for the outdated "licenses" array, just pick the first one
+        // also support the alternative spelling "licence"
+        if (node.package.license) {
+          val = node.package.license;
+        } else if (node.package.licence) {
+          val = node.package.licence;
+        } else if (Array.isArray(node.package.licenses)) {
+          val = node.package.licenses[0];
+        } else if (Array.isArray(node.package.licences)) {
+          val = node.package.licences[0];
+        }
+      } else if (node[key]) {
+        val = node[key];
+      } else {
+        val = node.package?.[key];
+      }
+      if (val && typeof val === "object") {
+        // We currently only use license and funding
+        /* istanbul ignore next - not used */
+        if (key === "license") {
+          val = val.type;
+        } else if (key === "funding") {
+          val = val.url;
+        }
+      }
+      if (!map.has(val)) {
+        map.set(val, new Set());
+      }
+      map.get(val).add(node);
+    }
+  }
+
+  delete(node) {
+    if (!this.has(node)) {
+      return;
+    }
+
+    super.delete(node.location);
+    for (const [key, map] of this.#index.entries()) {
+      let val;
+      if (node[key] !== undefined) {
+        val = node[key];
+      } else {
+        val = node.package?.[key];
+      }
+      const set = map.get(val);
+      if (set) {
+        set.delete(node);
+        if (set.size === 0) {
+          map.delete(node[key]);
+        }
+      }
+    }
+  }
+
+  query(key, val) {
+    const map = this.#index.get(key);
+    if (arguments.length === 2) {
+      if (map.has(val)) {
+        return map.get(val);
+      }
+      return new Set();
+    }
+    return map.keys();
+  }
+
+  has(node) {
+    return super.get(node.location) === node;
+  }
+
+  set() {
+    throw new Error("direct set() not supported, use inventory.add(node)");
+  }
+}
+
+export default Inventory;

package/lib/third-party/arborist/lib/link.js

@@ -0,0 +1,169 @@
+import { dirname } from "node:path";
+
+import Node from "./node.js";
+import relpath from "./relpath.js";
+
+const _loadDeps = Symbol.for("Arborist.Node._loadDeps");
+const _target = Symbol.for("_target");
+// defined by Node class
+const _delistFromMeta = Symbol.for("_delistFromMeta");
+const _refreshLocation = Symbol.for("_refreshLocation");
+class Link extends Node {
+  constructor(options) {
+    const { root, realpath, target, parent, fsParent, isStoreLink } = options;
+
+    if (!realpath && !(target && target.path)) {
+      throw new TypeError("must provide realpath for Link node");
+    }
+
+    super({
+      ...options,
+      realpath: realpath || target.path,
+      root:
+        root ||
+        (parent
+          ? parent.root
+          : fsParent
+            ? fsParent.root
+            : target
+              ? target.root
+              : null),
+    });
+
+    this.isStoreLink = isStoreLink || false;
+
+    if (target) {
+      this.target = target;
+    } else if (this.realpath === this.root.path) {
+      this.target = this.root;
+    } else {
+      this.target = new Node({
+        ...options,
+        path: realpath,
+        parent: null,
+        fsParent: null,
+        root: this.root,
+      });
+    }
+  }
+
+  get version() {
+    return this.target ? this.target.version : this.package.version || "";
+  }
+
+  get target() {
+    return this[_target];
+  }
+
+  set target(target) {
+    const current = this[_target];
+    if (target === current) {
+      return;
+    }
+
+    if (!target) {
+      if (current && current.linksIn) {
+        current.linksIn.delete(this);
+      }
+      if (this.path) {
+        this[_delistFromMeta]();
+        this[_target] = null;
+        this.package = {};
+        this[_refreshLocation]();
+      } else {
+        this[_target] = null;
+      }
+      return;
+    }
+
+    if (!this.path) {
+      // temp node pending assignment to a tree
+      // we know it's not in the inventory yet, because no path.
+      if (target.path) {
+        this.realpath = target.path;
+      } else {
+        target.path = target.realpath = this.realpath;
+      }
+      target.root = this.root;
+      this[_target] = target;
+      target.linksIn.add(this);
+      this.package = target.package;
+      return;
+    }
+
+    // have to refresh metadata, because either realpath or package
+    // is very likely changing.
+    this[_delistFromMeta]();
+    this.package = target.package;
+    this.realpath = target.path;
+    this[_refreshLocation]();
+
+    target.root = this.root;
+  }
+
+  // a link always resolves to the relative path to its target
+  get resolved() {
+    // the path/realpath guard is there for the benefit of setting
+    // these things in the "wrong" order
+    return this.path && this.realpath
+      ? `file:${relpath(dirname(this.path), this.realpath)}`
+      : null;
+  }
+
+  set resolved(r) {}
+
+  // deps are resolved on the target, not the Link
+  // so this is a no-op
+  [_loadDeps]() {}
+
+  // Forward overrides to the target only when a rule names a dep it needs, directly or transitively (npm/cli#9357, #9619).
+  recalculateOutEdgesOverrides() {
+    if (!this.target || !this.overrides) {
+      return;
+    }
+    if (!overrideMatchesSubtree(this.overrides, this.target)) {
+      return;
+    }
+    this.target.updateOverridesEdgeInAdded(this.overrides);
+  }
+
+  // links can't have children, only their targets can
+  // fix it to an empty list so that we can still call
+  // things that iterate over them, just as a no-op
+  get children() {
+    return new Map();
+  }
+
+  set children(c) {}
+
+  get isLink() {
+    return true;
+  }
+}
+
+// True when an override rule applies to an edge reachable from the target at any depth.
+// getEdgeRule matches on name and spec, returning the set itself when nothing applies, so a non-applicable version-qualified rule doesn't flip an intermediate node to "has overrides" (npm/cli#9357).
+// Not a method: runs from the Node super-constructor, before subclass private methods exist.
+const overrideMatchesSubtree = (overrides, target) => {
+  const seen = new Set();
+  const stack = [target];
+  while (stack.length) {
+    const node = stack.pop();
+    const resolved = node.isLink ? node.target : node;
+    if (seen.has(resolved)) {
+      continue;
+    }
+    seen.add(resolved);
+    for (const edge of resolved.edgesOut.values()) {
+      if (overrides.getEdgeRule(edge).name === edge.name) {
+        return true;
+      }
+      if (edge.to) {
+        stack.push(edge.to);
+      }
+    }
+  }
+  return false;
+};
+
+export default Link;