Init: RoggioApp Architecture, Prisma Schema, API MVP
This commit is contained in:
Clara Zetkin
+508
@@ -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 };
|
||||
Reference in New Issue
Block a user