@maizzle/framework 6.0.0-rc.1 → 6.0.0-rc.3

package/node_modules/giget/dist/_chunks/giget.mjs

@@ -0,0 +1,508 @@
+import { a as resolve$1, i as relative, n as basename$1, r as dirname$1 } from "./libs/nypm.mjs";
+import { createWriteStream, existsSync, readdirSync, renameSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { PassThrough, Readable, pipeline } from "node:stream";
+import { pipeline as pipeline$1 } from "node:stream/promises";
+import { spawn, spawnSync } from "node:child_process";
+import { homedir, tmpdir } from "node:os";
+import { promisify } from "node:util";
+import { join } from "node:path";
+//#region src/_utils.ts
+async function download(url, filePath, options = {}) {
+	const infoPath = filePath + ".json";
+	const info = JSON.parse(await readFile(infoPath, "utf8").catch(() => "{}"));
+	const etag = (await sendFetch(url, {
+		method: "HEAD",
+		headers: options.headers
+	}).catch(() => void 0))?.headers.get("etag");
+	if (info.etag === etag && existsSync(filePath)) return;
+	if (typeof etag === "string") info.etag = etag;
+	const response = await sendFetch(url, { headers: options.headers });
+	if (response.status >= 400) throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+	const stream = createWriteStream(filePath);
+	await promisify(pipeline)(response.body, stream);
+	await writeFile(infoPath, JSON.stringify(info), "utf8");
+}
+const inputRegex = /^(?<repo>[-\w.]+\/[-\w.]+)(?<subdir>[^#]+)?(?<ref>#[-\w./@]+)?/;
+const expandedInputRegex = /^(?<repo>[-\w.]+(?:\/[-\w.]+)+?)(?:::(?<subdir>[^#]*))?(?<ref>#[-\w./@]+)?$/;
+function parseGitURI(input, options) {
+	const useExpanded = options?.expandRepo || input.includes("::");
+	const m = input.match(useExpanded ? expandedInputRegex : inputRegex)?.groups || {};
+	const subdir = useExpanded ? m.subdir ? "/" + m.subdir : "/" : m.subdir || "/";
+	return {
+		repo: m.repo || "",
+		subdir,
+		ref: m.ref ? m.ref.slice(1) : "main"
+	};
+}
+function debug(...args) {
+	if (process.env.DEBUG) console.debug("[giget]", ...args);
+}
+async function sendFetch(url, options = {}) {
+	if (options.headers?.["sec-fetch-mode"]) options.mode = options.headers["sec-fetch-mode"];
+	const res = await fetch(url, {
+		...options,
+		headers: normalizeHeaders(options.headers)
+	}).catch((error) => {
+		throw new Error(`Failed to download ${url}: ${error}`, { cause: error });
+	});
+	if (options.validateStatus && res.status >= 400) throw new Error(`Failed to fetch ${url}: ${res.status} ${res.statusText}`);
+	return res;
+}
+function cacheDirectory() {
+	const cacheDir = process.env.XDG_CACHE_HOME ? resolve$1(process.env.XDG_CACHE_HOME, "giget") : resolve$1(homedir(), ".cache/giget");
+	if (process.platform === "win32") {
+		const windowsCacheDir = resolve$1(tmpdir(), "giget");
+		if (!existsSync(windowsCacheDir) && existsSync(cacheDir)) try {
+			renameSync(cacheDir, windowsCacheDir);
+		} catch {}
+		return windowsCacheDir;
+	}
+	return cacheDir;
+}
+function normalizeHeaders(headers = {}) {
+	const normalized = {};
+	for (const [key, value] of Object.entries(headers)) {
+		if (!value) continue;
+		normalized[key.toLowerCase()] = value;
+	}
+	return normalized;
+}
+function currentShell() {
+	if (process.env.SHELL) return process.env.SHELL;
+	if (process.platform === "win32") return "cmd.exe";
+	return "/bin/bash";
+}
+function startShell(cwd) {
+	cwd = resolve$1(cwd);
+	const shell = currentShell();
+	console.info(`(experimental) Opening shell in ${relative(process.cwd(), cwd)}...`);
+	spawnSync(shell, [], {
+		cwd,
+		shell: true,
+		stdio: "inherit"
+	});
+}
+//#endregion
+//#region src/git.ts
+const git = (input, options) => {
+	const parsed = parseGitCloneURI(input);
+	return {
+		name: parsed.name,
+		version: parsed.subdir ? `${parsed.version || "default"}-${parsed.subdir.replaceAll("/", "-")}` : parsed.version,
+		tar: ({ auth } = {}) => _cloneAndTar(parsed, auth ?? options.auth)
+	};
+};
+function parseGitCloneURI(input, opts = {}) {
+	const cwd = opts.cwd ?? process.cwd();
+	let uri = input.replace(/#.*$/, "");
+	let pathSubdir;
+	if (/^[./]/.test(input)) uri = resolve$1(cwd, uri);
+	else if (/^https?:\/\//.test(uri)) {
+		const httpMatch = /^(https?:\/\/[^/]+)\/([\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (httpMatch) {
+			const [, origin, repo, rest] = httpMatch;
+			uri = `${origin}/${repo}`;
+			if (rest) pathSubdir = rest;
+		}
+	} else if (uri.includes("@")) {
+		const sshMatch = /^(.*?:[\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (sshMatch) {
+			const [, repoUri, rest] = sshMatch;
+			uri = repoUri;
+			if (rest) pathSubdir = rest;
+		}
+	} else {
+		const hostMap = {
+			"github:": "https://github.com/",
+			"gh:": "https://github.com/",
+			"gitlab:": "https://gitlab.com/",
+			"bitbucket:": "https://bitbucket.org/",
+			"sourcehut:": "https://git.sr.ht/~"
+		};
+		const host = /^(.+?:)/.exec(uri)?.at(1);
+		if (host && hostMap[host]) uri = uri.replace(host, hostMap[host]);
+		else if (!host) uri = `${(process.env.GIGET_GIT_HOST || "https://github.com/").replace(/\/$/, "")}/${uri}`;
+		const httpMatch = /^(https?:\/\/[^/]+\/~?[\w.-]+\/[\w.-]+?)(?:\.git)?(?:\/(.+))?$/.exec(uri);
+		if (httpMatch) {
+			const [, repoUri, rest] = httpMatch;
+			uri = repoUri;
+			if (rest) pathSubdir = rest;
+		}
+	}
+	const name = uri.replace(/^https?:\/\//, "").replace(/^.+@/, "").replace(/(\.git)?(#.*)?$/, "").replace(/^\W+/, "").replaceAll(/[:/]/g, "-");
+	const [version, hashSubdir] = /#(.+)$/.exec(input)?.at(1)?.split(":") ?? [];
+	const resolvedVersion = version || void 0;
+	const subdir = hashSubdir || pathSubdir;
+	return {
+		uri,
+		name,
+		...resolvedVersion && { version: resolvedVersion },
+		...subdir && { subdir }
+	};
+}
+async function _cloneAndTar(parsed, token) {
+	const tmpDir = await mkdtemp(join(tmpdir(), "giget-git-"));
+	if (token && /[\r\n]/.test(token)) throw new Error("Auth token must not contain newline characters");
+	const execEnv = {
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+	if (token) {
+		execEnv.GIT_CONFIG_COUNT = "1";
+		execEnv.GIT_CONFIG_KEY_0 = "http.extraHeader";
+		execEnv.GIT_CONFIG_VALUE_0 = `Authorization: Bearer ${token}`;
+	}
+	const execOpts = {
+		env: execEnv,
+		timeout: 6e4
+	};
+	const status = _createStatus();
+	const gitExec = (args) => _gitSpawn(args, execOpts, status);
+	const gitExecIn = (args) => _gitSpawn(args, {
+		...execOpts,
+		cwd: tmpDir
+	}, status);
+	try {
+		const cloneArgs = [
+			"clone",
+			"--progress",
+			"--depth",
+			"1"
+		];
+		if (parsed.subdir) cloneArgs.push("--filter=blob:none", "--sparse", "--no-checkout");
+		if (parsed.version) cloneArgs.push("--branch", parsed.version);
+		cloneArgs.push("--", parsed.uri, tmpDir);
+		try {
+			status.update("Cloning...");
+			await gitExec(cloneArgs);
+			status.update("Cloned.");
+		} catch (cloneError) {
+			if (!parsed.version) throw cloneError;
+			debug("Shallow clone failed, falling back to full clone:", cloneError);
+			status.update("Shallow clone failed, cloning...");
+			await rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+			await mkdir(tmpDir, { recursive: true });
+			await gitExecIn(["init"]);
+			await gitExecIn([
+				"remote",
+				"add",
+				"origin",
+				parsed.uri
+			]);
+			await gitExecIn(["fetch", "origin"]);
+			await gitExecIn(["checkout", parsed.version]);
+			status.update("Fetched.");
+		}
+		if (parsed.subdir) {
+			status.update(`Sparse checkout ${parsed.subdir}...`);
+			await gitExecIn([
+				"sparse-checkout",
+				"set",
+				parsed.subdir
+			]);
+			await gitExecIn(["checkout"]);
+		}
+		status.update("Packing...");
+		const tarDir = parsed.subdir ? join(tmpDir, parsed.subdir) : tmpDir;
+		const { create } = await import("./libs/tar.mjs").then((n) => n.t);
+		status.done();
+		const stream = create({
+			gzip: true,
+			cwd: tarDir,
+			filter: (path) => !path.startsWith(".git/") && path !== ".git" && !path.startsWith("./.git/") && path !== "./.git"
+		}, ["."]).pipe(new PassThrough());
+		let cleaned = false;
+		const cleanup = () => {
+			if (cleaned) return;
+			cleaned = true;
+			rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		};
+		stream.on("end", cleanup);
+		stream.on("error", cleanup);
+		stream.on("close", cleanup);
+		return stream;
+	} catch (error) {
+		status.done();
+		await rm(tmpDir, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+const _spinnerFrames = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+function _gitSpawn(args, opts, status) {
+	return new Promise((resolve, reject) => {
+		const proc = spawn("git", args, {
+			...opts,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		proc.stdout.resume();
+		let lastLine = "";
+		proc.stderr?.on("data", (chunk) => {
+			const str = chunk.toString();
+			for (const line of str.split(/[\r\n]/)) {
+				const clean = line.trim();
+				if (clean) lastLine = clean;
+			}
+			if (status) status.update(lastLine);
+		});
+		proc.on("close", (code) => {
+			if (code === 0) resolve(lastLine);
+			else reject(/* @__PURE__ */ new Error(`git ${args[0]} exited with code ${code}. Is git installed?`));
+		});
+		proc.on("error", (err) => {
+			if (err.code === "ENOENT") reject(/* @__PURE__ */ new Error("git is not installed or not found in PATH"));
+			else reject(err);
+		});
+	});
+}
+function _createStatus() {
+	if (!process.stderr.isTTY) return {
+		update(_text) {},
+		done() {}
+	};
+	let msg = "";
+	let frame = 0;
+	const render = () => {
+		const spinner = _spinnerFrames[frame % _spinnerFrames.length];
+		frame++;
+		process.stderr.write(`\x1B[2K\r\x1B[2m${spinner} ${msg}\x1B[0m`);
+	};
+	const interval = setInterval(render, 80);
+	return {
+		update(text) {
+			msg = text;
+			render();
+		},
+		done() {
+			clearInterval(interval);
+			process.stderr.write("\x1B[2K\r");
+		}
+	};
+}
+//#endregion
+//#region src/providers.ts
+const http = async (input, options) => {
+	if (input.endsWith(".json")) return await _httpJSON(input, options);
+	const url = new URL(input);
+	let name = basename$1(url.pathname);
+	try {
+		const head = await sendFetch(url.href, {
+			method: "HEAD",
+			validateStatus: true,
+			headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+		});
+		if ((head.headers.get("content-type") || "").includes("application/json")) return await _httpJSON(input, options);
+		const filename = head.headers.get("content-disposition")?.match(/filename="?(.+)"?/)?.[1];
+		if (filename) name = filename.split(".")[0];
+	} catch (error) {
+		debug(`Failed to fetch HEAD for ${url.href}:`, error);
+	}
+	return {
+		name: `${name}-${url.href.slice(0, 8)}`,
+		version: "",
+		subdir: "",
+		tar: url.href,
+		defaultDir: name,
+		headers: { Authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+	};
+};
+const _httpJSON = async (input, options) => {
+	const info = await (await sendFetch(input, {
+		validateStatus: true,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 }
+	})).json();
+	if (!info.tar || !info.name) throw new Error(`Invalid template info from ${input}. name or tar fields are missing!`);
+	return info;
+};
+const github = (input, options) => {
+	const parsed = parseGitURI(input);
+	const githubAPIURL = process.env.GIGET_GITHUB_URL || "https://api.github.com";
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: {
+			Authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			Accept: "application/vnd.github+json",
+			"X-GitHub-Api-Version": "2022-11-28"
+		},
+		url: `${githubAPIURL.replace("api.github.com", "github.com")}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+		tar: `${githubAPIURL}/repos/${parsed.repo}/tarball/${parsed.ref}`
+	};
+};
+const gitlab = (input, options) => {
+	const parsed = parseGitURI(input, { expandRepo: true });
+	const gitlab = process.env.GIGET_GITLAB_URL || "https://gitlab.com";
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: {
+			authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			"sec-fetch-mode": "same-origin"
+		},
+		url: `${gitlab}/${parsed.repo}/tree/${parsed.ref}${parsed.subdir}`,
+		tar: `${gitlab}/${parsed.repo}/-/archive/${parsed.ref}.tar.gz`
+	};
+};
+const bitbucket = (input, options) => {
+	const parsed = parseGitURI(input);
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 },
+		url: `https://bitbucket.com/${parsed.repo}/src/${parsed.ref}${parsed.subdir}`,
+		tar: `https://bitbucket.org/${parsed.repo}/get/${parsed.ref}.tar.gz`
+	};
+};
+const sourcehut = (input, options) => {
+	const parsed = parseGitURI(input);
+	return {
+		name: parsed.repo.replace("/", "-"),
+		version: parsed.ref,
+		subdir: parsed.subdir,
+		headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 },
+		url: `https://git.sr.ht/~${parsed.repo}/tree/${parsed.ref}/item${parsed.subdir}`,
+		tar: `https://git.sr.ht/~${parsed.repo}/archive/${parsed.ref}.tar.gz`
+	};
+};
+const providers = {
+	http,
+	https: http,
+	git,
+	github,
+	gh: github,
+	gitlab,
+	bitbucket,
+	sourcehut
+};
+//#endregion
+//#region src/registry.ts
+const DEFAULT_REGISTRY = "https://raw.githubusercontent.com/unjs/giget/main/templates";
+const registryProvider = (registryEndpoint = DEFAULT_REGISTRY, options = {}) => {
+	return (async (input) => {
+		const start = Date.now();
+		const registryURL = `${registryEndpoint}/${input}.json`;
+		const result = await sendFetch(registryURL, { headers: { authorization: options.auth ? `Bearer ${options.auth}` : void 0 } });
+		if (result.status >= 400) throw new Error(`Failed to download ${input} template info from ${registryURL}: ${result.status} ${result.statusText}`);
+		const info = await result.json();
+		if (!info.tar || !info.name) throw new Error(`Invalid template info from ${registryURL}. name or tar fields are missing!`);
+		debug(`Fetched ${input} template info from ${registryURL} in ${Date.now() - start}ms`);
+		return info;
+	});
+};
+//#endregion
+//#region src/giget.ts
+const sourceProtoRe = /^([\w+-.]+):/;
+async function downloadTemplate(input, options = {}) {
+	options.registry = process.env.GIGET_REGISTRY ?? options.registry;
+	options.auth = process.env.GIGET_AUTH ?? options.auth;
+	const registry = options.registry === false ? void 0 : registryProvider(options.registry, { auth: options.auth });
+	let providerName = options.provider || (registry ? "registry" : "github");
+	let source = input;
+	const sourceProviderMatch = input.match(sourceProtoRe);
+	if (sourceProviderMatch) {
+		providerName = sourceProviderMatch[1];
+		source = input.slice(sourceProviderMatch[0].length);
+		if (providerName === "http" || providerName === "https") source = input;
+	}
+	if (providerName.endsWith("+git")) {
+		source = `${providerName.slice(0, -4)}:${source}`;
+		providerName = "git";
+	}
+	const provider = options.providers?.[providerName] || providers[providerName] || registry;
+	if (!provider) throw new Error(`Unsupported provider: ${providerName}`);
+	const template = await Promise.resolve().then(() => provider(source, { auth: options.auth })).catch((error) => {
+		throw new Error(`Failed to download template from ${providerName}: ${error.message}`);
+	});
+	if (!template) throw new Error(`Failed to resolve template from ${providerName}`);
+	template.name = (template.name || "template").replace(/[^\da-z-]/gi, "-");
+	template.defaultDir = (template.defaultDir || template.name).replace(/[^\da-z-]/gi, "-");
+	const tarPath = resolve$1(resolve$1(cacheDirectory(), providerName, template.name), (template.version || template.name) + ".tar.gz");
+	if (options.preferOffline && existsSync(tarPath)) options.offline = true;
+	if (!options.offline) {
+		await mkdir(dirname$1(tarPath), { recursive: true });
+		const s = Date.now();
+		if (typeof template.tar === "function") {
+			const tarFn = template.tar;
+			await (async () => {
+				const stream = await tarFn({ auth: options.auth });
+				await pipeline$1(stream instanceof Readable ? stream : Readable.fromWeb(stream), createWriteStream(tarPath));
+			})().catch((error) => {
+				if (!existsSync(tarPath)) throw error;
+				debug("Download error. Using cached version:", error);
+				options.offline = true;
+			});
+		} else await download(template.tar, tarPath, { headers: {
+			Authorization: options.auth ? `Bearer ${options.auth}` : void 0,
+			...normalizeHeaders(template.headers)
+		} }).catch((error) => {
+			if (!existsSync(tarPath)) throw error;
+			debug("Download error. Using cached version:", error);
+			options.offline = true;
+		});
+		debug(`Downloaded to ${tarPath} in ${Date.now() - s}ms`);
+	}
+	if (!existsSync(tarPath)) throw new Error(`Tarball not found: ${tarPath} (offline: ${options.offline})`);
+	const extractPath = resolve$1(resolve$1(options.cwd || "."), options.dir || template.defaultDir);
+	if (options.forceClean) await rm(extractPath, {
+		recursive: true,
+		force: true
+	});
+	if (!options.force && existsSync(extractPath) && readdirSync(extractPath).length > 0) throw new Error(`Destination ${extractPath} already exists.`);
+	await mkdir(extractPath, { recursive: true });
+	const s = Date.now();
+	const subdir = template.subdir?.replace(/^\//, "") || "";
+	const { extract } = await import("./libs/tar.mjs").then((n) => n.t);
+	await extract({
+		file: tarPath,
+		cwd: extractPath,
+		onReadEntry(entry) {
+			entry.path = entry.path.split("/").splice(1).join("/");
+			if (subdir) if (entry.path.startsWith(subdir + "/")) entry.path = entry.path.slice(subdir.length);
+			else entry.path = "";
+		}
+	});
+	debug(`Extracted to ${extractPath} in ${Date.now() - s}ms`);
+	if (options.install) {
+		debug("Installing dependencies...");
+		const { installDependencies } = await import("./libs/nypm.mjs").then((n) => n.t);
+		await installDependencies({
+			cwd: extractPath,
+			silent: options.silent,
+			...typeof options.install === "object" ? options.install : {}
+		});
+	}
+	return {
+		...template,
+		source,
+		dir: extractPath
+	};
+}
+//#endregion
+export { registryProvider as n, startShell as r, downloadTemplate as t };