320 lines
9.0 KiB
Plaintext
320 lines
9.0 KiB
Plaintext
import require$$0, { promises } from 'fs';
|
|
import p from 'path';
|
|
import process from 'process';
|
|
import { fileURLToPath } from 'url';
|
|
import { execa } from 'execa';
|
|
|
|
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);
|
|
}
|
|
});
|
|
|
|
// 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 ? promises.stat : promises.lstat;
|
|
return pLocate(paths, async (path_) => {
|
|
try {
|
|
const stat = await statFunction(p.resolve(cwd, path_));
|
|
return matchType(type, stat);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}, { concurrency, preserveOrder });
|
|
}
|
|
function toPath2(urlOrPath) {
|
|
return urlOrPath instanceof URL ? fileURLToPath(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 = p.resolve(toPath2(options.cwd) ?? "");
|
|
const { root } = p.parse(directory);
|
|
const stopAt = p.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(p.resolve(directory, foundPath));
|
|
}
|
|
if (directory === stopAt || matches.length >= limit) {
|
|
break;
|
|
}
|
|
directory = p.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"];
|
|
var LOCKS = {
|
|
"bun.lockb": "bun",
|
|
"pnpm-lock.yaml": "pnpm",
|
|
"yarn.lock": "yarn",
|
|
"package-lock.json": "npm",
|
|
"npm-shrinkwrap.json": "npm"
|
|
};
|
|
async function detectPackageManager(cwd = process.cwd()) {
|
|
let agent = null;
|
|
const lockPath = await findUp(Object.keys(LOCKS), { cwd });
|
|
let packageJsonPath;
|
|
if (lockPath)
|
|
packageJsonPath = p.resolve(lockPath, "../package.json");
|
|
else
|
|
packageJsonPath = await findUp("package.json", { cwd });
|
|
if (packageJsonPath && require$$0.existsSync(packageJsonPath)) {
|
|
try {
|
|
const pkg = JSON.parse(require$$0.readFileSync(packageJsonPath, "utf8"));
|
|
if (typeof pkg.packageManager === "string") {
|
|
const [name, version] = pkg.packageManager.split("@");
|
|
if (name === "yarn" && Number.parseInt(version) > 1)
|
|
agent = "yarn@berry";
|
|
else if (name === "pnpm" && Number.parseInt(version) < 7)
|
|
agent = "pnpm@6";
|
|
else if (AGENTS.includes(name))
|
|
agent = name;
|
|
else
|
|
console.warn("[ni] Unknown packageManager:", pkg.packageManager);
|
|
}
|
|
} catch {
|
|
}
|
|
}
|
|
if (!agent && lockPath)
|
|
agent = LOCKS[p.basename(lockPath)];
|
|
return agent;
|
|
}
|
|
async function installPackage(names, options = {}) {
|
|
const detectedAgent = options.packageManager || await detectPackageManager(options.cwd) || "npm";
|
|
const [agent] = detectedAgent.split("@");
|
|
if (!Array.isArray(names))
|
|
names = [names];
|
|
const args = options.additionalArgs || [];
|
|
if (options.preferOffline) {
|
|
if (detectedAgent === "yarn@berry")
|
|
args.unshift("--cached");
|
|
else
|
|
args.unshift("--prefer-offline");
|
|
}
|
|
return execa(
|
|
agent,
|
|
[
|
|
agent === "yarn" ? "add" : "install",
|
|
options.dev ? "-D" : "",
|
|
...args,
|
|
...names
|
|
].filter(Boolean),
|
|
{
|
|
stdio: options.silent ? "ignore" : "inherit",
|
|
cwd: options.cwd
|
|
}
|
|
);
|
|
}
|
|
|
|
export { detectPackageManager, installPackage };
|