@antfu/install-pkg - npm Package Compare versions

Comparing version 0.3.0 to 0.3.1

dist/index.js

@@ -0,6 +1,266 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+
 // src/detect.ts
-import fs from "fs";
+import fs2 from "fs";
+import path3 from "path";
+import process2 from "process";
+
+// node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
+import path2 from "path";
+
+// node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+import process from "process";
 import path from "path";
-import process from "process";
-import { findUp } from "find-up";
+import fs, { promises as fsPromises } from "fs";
+import { fileURLToPath } from "url";
+
+// node_modules/.pnpm/yocto-queue@1.0.0/node_modules/yocto-queue/index.js
+var Node = class {
+  constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "next");
+    this.value = value;
+  }
+};
+var _head, _tail, _size;
+var Queue = class {
+  constructor() {
+    __privateAdd(this, _head, void 0);
+    __privateAdd(this, _tail, void 0);
+    __privateAdd(this, _size, void 0);
+    this.clear();
+  }
+  enqueue(value) {
+    const node = new Node(value);
+    if (__privateGet(this, _head)) {
+      __privateGet(this, _tail).next = node;
+      __privateSet(this, _tail, node);
+    } else {
+      __privateSet(this, _head, node);
+      __privateSet(this, _tail, node);
+    }
+    __privateWrapper(this, _size)._++;
+  }
+  dequeue() {
+    const current = __privateGet(this, _head);
+    if (!current) {
+      return;
+    }
+    __privateSet(this, _head, __privateGet(this, _head).next);
+    __privateWrapper(this, _size)._--;
+    return current.value;
+  }
+  clear() {
+    __privateSet(this, _head, void 0);
+    __privateSet(this, _tail, void 0);
+    __privateSet(this, _size, 0);
+  }
+  get size() {
+    return __privateGet(this, _size);
+  }
+  *[Symbol.iterator]() {
+    let current = __privateGet(this, _head);
+    while (current) {
+      yield current.value;
+      current = current.next;
+    }
+  }
+};
+_head = new WeakMap();
+_tail = new WeakMap();
+_size = new WeakMap();
+
+// node_modules/.pnpm/p-limit@4.0.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+  if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
+    throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+  }
+  const queue = new Queue();
+  let activeCount = 0;
+  const next = () => {
+    activeCount--;
+    if (queue.size > 0) {
+      queue.dequeue()();
+    }
+  };
+  const run = async (fn, resolve, args) => {
+    activeCount++;
+    const result = (async () => fn(...args))();
+    resolve(result);
+    try {
+      await result;
+    } catch {
+    }
+    next();
+  };
+  const enqueue = (fn, resolve, args) => {
+    queue.enqueue(run.bind(void 0, fn, resolve, args));
+    (async () => {
+      await Promise.resolve();
+      if (activeCount < concurrency && queue.size > 0) {
+        queue.dequeue()();
+      }
+    })();
+  };
+  const generator = (fn, ...args) => new Promise((resolve) => {
+    enqueue(fn, resolve, args);
+  });
+  Object.defineProperties(generator, {
+    activeCount: {
+      get: () => activeCount
+    },
+    pendingCount: {
+      get: () => queue.size
+    },
+    clearQueue: {
+      value: () => {
+        queue.clear();
+      }
+    }
+  });
+  return generator;
+}
+
+// node_modules/.pnpm/p-locate@6.0.0/node_modules/p-locate/index.js
+var EndError = class extends Error {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+};
+var testElement = async (element, tester) => tester(await element);
+var finder = async (element) => {
+  const values = await Promise.all(element);
+  if (values[1] === true) {
+    throw new EndError(values[0]);
+  }
+  return false;
+};
+async function pLocate(iterable, tester, {
+  concurrency = Number.POSITIVE_INFINITY,
+  preserveOrder = true
+} = {}) {
+  const limit = pLimit(concurrency);
+  const items = [...iterable].map((element) => [element, limit(testElement, element, tester)]);
+  const checkLimit = pLimit(preserveOrder ? 1 : Number.POSITIVE_INFINITY);
+  try {
+    await Promise.all(items.map((element) => checkLimit(finder, element)));
+  } catch (error) {
+    if (error instanceof EndError) {
+      return error.value;
+    }
+    throw error;
+  }
+}
+
+// node_modules/.pnpm/locate-path@7.2.0/node_modules/locate-path/index.js
+var typeMappings = {
+  directory: "isDirectory",
+  file: "isFile"
+};
+function checkType(type) {
+  if (Object.hasOwnProperty.call(typeMappings, type)) {
+    return;
+  }
+  throw new Error(`Invalid type specified: ${type}`);
+}
+var matchType = (type, stat) => stat[typeMappings[type]]();
+var toPath = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
+async function locatePath(paths, {
+  cwd = process.cwd(),
+  type = "file",
+  allowSymlinks = true,
+  concurrency,
+  preserveOrder
+} = {}) {
+  checkType(type);
+  cwd = toPath(cwd);
+  const statFunction = allowSymlinks ? fsPromises.stat : fsPromises.lstat;
+  return pLocate(paths, async (path_) => {
+    try {
+      const stat = await statFunction(path.resolve(cwd, path_));
+      return matchType(type, stat);
+    } catch {
+      return false;
+    }
+  }, { concurrency, preserveOrder });
+}
+
+// node_modules/.pnpm/unicorn-magic@0.1.0/node_modules/unicorn-magic/node.js
+import { fileURLToPath as fileURLToPath2 } from "url";
+function toPath2(urlOrPath) {
+  return urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
+}
+
+// node_modules/.pnpm/find-up@7.0.0/node_modules/find-up/index.js
+var findUpStop = Symbol("findUpStop");
+async function findUpMultiple(name, options = {}) {
+  let directory = path2.resolve(toPath2(options.cwd) ?? "");
+  const { root } = path2.parse(directory);
+  const stopAt = path2.resolve(directory, toPath2(options.stopAt ?? root));
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const paths = [name].flat();
+  const runMatcher = async (locateOptions) => {
+    if (typeof name !== "function") {
+      return locatePath(paths, locateOptions);
+    }
+    const foundPath = await name(locateOptions.cwd);
+    if (typeof foundPath === "string") {
+      return locatePath([foundPath], locateOptions);
+    }
+    return foundPath;
+  };
+  const matches = [];
+  while (true) {
+    const foundPath = await runMatcher({ ...options, cwd: directory });
+    if (foundPath === findUpStop) {
+      break;
+    }
+    if (foundPath) {
+      matches.push(path2.resolve(directory, foundPath));
+    }
+    if (directory === stopAt || matches.length >= limit) {
+      break;
+    }
+    directory = path2.dirname(directory);
+  }
+  return matches;
+}
+async function findUp(name, options = {}) {
+  const matches = await findUpMultiple(name, { ...options, limit: 1 });
+  return matches[0];
+}
+
+// src/detect.ts
 var AGENTS = ["pnpm", "yarn", "npm", "pnpm@6", "yarn@berry", "bun"];
@@ -14,3 +274,3 @@ var LOCKS = {
 };
-async function detectPackageManager(cwd = process.cwd()) {
+async function detectPackageManager(cwd = process2.cwd()) {
   let agent = null;
@@ -20,8 +280,8 @@ const lockPath = await findUp(Object.keys(LOCKS), { cwd });
   if (lockPath)
-    packageJsonPath = path.resolve(lockPath, "../package.json");
+    packageJsonPath = path3.resolve(lockPath, "../package.json");
   else
     packageJsonPath = await findUp("package.json", { cwd });
-  if (packageJsonPath && fs.existsSync(packageJsonPath)) {
+  if (packageJsonPath && fs2.existsSync(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
       if (typeof pkg.packageManager === "string") {
@@ -42,3 +302,3 @@ const [name, version] = pkg.packageManager.split("@");
   if (!agent && lockPath)
-    agent = LOCKS[path.basename(lockPath)];
+    agent = LOCKS[path3.basename(lockPath)];
   return agent;
@@ -45,0 +305,0 @@ }

package.json

 {
   "name": "@antfu/install-pkg",
   "type": "module",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "packageManager": "pnpm@8.11.0",
@@ -39,4 +39,3 @@ "description": "Install package programmatically.",
   "dependencies": {
-    "execa": "^8.0.1",
-    "find-up": "^7.0.0"
+    "execa": "^8.0.1"
   },
@@ -50,2 +49,3 @@ "devDependencies": {
     "esno": "^4.0.0",
+    "find-up": "^7.0.0",
     "publint": "^0.2.5",
@@ -52,0 +52,0 @@ "tsup": "^8.0.1",

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

26450

increased by138.76%

Dependency count

1

decreased by-50%

Lines of code

701

increased by250.5%

Worsened metrics

Dev dependency count

10

increased by11.11%

Number of low supply chain risk alerts

5

increased by150%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• - Removedfind-up@^7.0.0

• - Removedfind-up@7.0.0(transitive)

• - Removedlocate-path@7.2.0(transitive)

• - Removedp-limit@4.0.0(transitive)

• - Removedp-locate@6.0.0(transitive)

• - Removedpath-exists@5.0.0(transitive)

• - Removedunicorn-magic@0.1.0(transitive)

• - Removedyocto-queue@1.1.1(transitive)