@youcan/cli-kit 2.8.1 → 2.8.2

package/dist/node/crypto.js

@@ -1,28 +1,39 @@
-import crypto from 'node:crypto';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import crypto from "node:crypto";
+//#region lib/node/crypto.ts
+var crypto_exports = /* @__PURE__ */ __exportAll({
+	base64URLEncode: () => base64URLEncode,
+	fileHash: () => fileHash,
+	hashString: () => hashString,
+	randomBytes: () => randomBytes,
+	randomHex: () => randomHex,
+	randomUUID: () => randomUUID,
+	sha1: () => sha1,
+	sha256: () => sha256
+});
 function randomHex(size) {
-    return crypto.randomBytes(size).toString('hex');
+	return crypto.randomBytes(size).toString("hex");
 }
 function base64URLEncode(str) {
-    return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]/g, '');
+	return str.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/[=]/g, "");
 }
 function sha256(str) {
-    return crypto.createHash('sha256').update(str).digest();
+	return crypto.createHash("sha256").update(str).digest();
 }
 function sha1(str) {
-    return crypto.createHash('sha1').update(str).digest('hex');
+	return crypto.createHash("sha1").update(str).digest("hex");
 }
 function hashString(str) {
-    return crypto.createHash('sha1').update(str).digest('hex');
+	return crypto.createHash("sha1").update(str).digest("hex");
 }
 function fileHash(buff) {
-    return crypto.createHash('md5').update(buff).digest('hex');
+	return crypto.createHash("md5").update(buff).digest("hex");
 }
 function randomBytes(size) {
-    return crypto.randomBytes(size);
+	return crypto.randomBytes(size);
 }
 function randomUUID() {
-    return crypto.randomUUID();
+	return crypto.randomUUID();
 }
-
-export { base64URLEncode, fileHash, hashString, randomBytes, randomHex, randomUUID, sha1, sha256 };
+//#endregion
+export { base64URLEncode, crypto_exports, fileHash, hashString, randomBytes, randomHex, randomUUID, sha1, sha256 };

package/dist/node/env.js

@@ -1,41 +1,36 @@
-import process from 'node:process';
-import { ENV_VARS } from '../internal/node/constants.js';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { ENV_VARS } from "../internal/node/constants.js";
+import process from "node:process";
+//#region lib/node/env.ts
+var env_exports = /* @__PURE__ */ __exportAll({
+	apiHostname: () => apiHostname,
+	get: () => get,
+	oauthClientId: () => oauthClientId,
+	sellerAreaHostname: () => sellerAreaHostname
+});
 function get(key) {
-    return process.env[ENV_VARS[key]];
+	return process.env[ENV_VARS[key]];
 }
 function oauthClientId() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return '1';
-        case 'test':
-            return '11';
-        case 'prod':
-        default:
-            return '398';
-    }
+	switch (get("HOST_ENV")) {
+		case "dev": return "1";
+		case "test": return "11";
+		default: return "398";
+	}
 }
 function sellerAreaHostname() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return 'seller-area.dotshop.com';
-        case 'test':
-            return 'seller-area.testyoucan.shop';
-        case 'prod':
-        default:
-            return 'seller-area.youcan.shop';
-    }
+	switch (get("HOST_ENV")) {
+		case "dev": return "seller-area.dotshop.com";
+		case "test": return "seller-area.testyoucan.shop";
+		default: return "seller-area.youcan.shop";
+	}
 }
 function apiHostname() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return 'api.dotshop.com';
-        case 'test':
-            return 'api.testyoucan.shop';
-        case 'prod':
-        default:
-            return 'api.youcan.shop';
-    }
+	switch (get("HOST_ENV")) {
+		case "dev": return "api.dotshop.com";
+		case "test": return "api.testyoucan.shop";
+		default: return "api.youcan.shop";
+	}
 }
-
-export { apiHostname, get, oauthClientId, sellerAreaHostname };
+//#endregion
+export { apiHostname, env_exports, get, oauthClientId, sellerAreaHostname };

package/dist/node/filesystem.js

@@ -1,138 +1,144 @@
-import { createWriteStream, createReadStream } from 'node:fs';
-import FilesystemPromises from 'node:fs/promises';
-import { pipeline } from 'node:stream/promises';
-import { createGunzip } from 'node:zlib';
-import archiver from 'archiver';
-import chokidar from 'chokidar';
-import FsExtra from 'fs-extra';
-import { glob as glob$1 } from 'glob';
-import * as tar from 'tar';
-import { temporaryDirectoryTask } from 'tempy';
-import 'change-case';
-import './cli.js';
-import 'conf';
-import 'env-paths';
-import 'formdata-node';
-import 'formdata-node/file-from-path';
-import 'simple-git';
-import 'execa';
-import 'find-process';
-import 'get-port';
-import 'tcp-port-used';
-import 'node-fetch';
-import 'ramda';
-import { resolve } from './path.js';
-import 'kleur';
-import 'dayjs';
-import '../ui/components/DevOutput.js';
-import 'react';
-import 'ink';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { resolve } from "./path.js";
+import "../index.js";
+import { createReadStream, createWriteStream } from "node:fs";
+import FilesystemPromises from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+import archiver from "archiver";
+import chokidar from "chokidar";
+import FsExtra from "fs-extra";
+import { glob as glob$1 } from "glob";
+import * as tar from "tar";
+import { temporaryDirectoryTask } from "tempy";
+//#region lib/node/filesystem.ts
+var filesystem_exports = /* @__PURE__ */ __exportAll({
+	archived: () => archived,
+	chmod: () => chmod,
+	decompressGzip: () => decompressGzip,
+	exists: () => exists,
+	extractTar: () => extractTar,
+	glob: () => glob,
+	isDirectory: () => isDirectory,
+	isExecutable: () => isExecutable,
+	mkdir: () => mkdir,
+	move: () => move,
+	readFile: () => readFile,
+	readJsonFile: () => readJsonFile,
+	readdir: () => readdir,
+	rm: () => rm,
+	stat: () => stat,
+	tapIntoTmp: () => tapIntoTmp,
+	unlink: () => unlink,
+	watch: () => watch,
+	writeFile: () => writeFile,
+	writeJsonFile: () => writeJsonFile
+});
 async function exists(path) {
-    try {
-        await FilesystemPromises.access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
+	try {
+		await FilesystemPromises.access(path);
+		return true;
+	} catch {
+		return false;
+	}
 }
 async function isExecutable(path) {
-    if (!await exists(path)) {
-        return false;
-    }
-    try {
-        await FilesystemPromises.access(path, FilesystemPromises.constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
+	if (!await exists(path)) return false;
+	try {
+		await FilesystemPromises.access(path, FilesystemPromises.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
 }
 async function isDirectory(path) {
-    try {
-        const stats = await FilesystemPromises.stat(path);
-        return stats.isDirectory();
-    }
-    catch {
-        return false;
-    }
+	try {
+		return (await FilesystemPromises.stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
 }
 async function tapIntoTmp(callback) {
-    return temporaryDirectoryTask(callback);
+	return temporaryDirectoryTask(callback);
 }
 async function mkdir(path) {
-    await FilesystemPromises.mkdir(path, { recursive: true });
+	await FilesystemPromises.mkdir(path, { recursive: true });
 }
 async function rm(path) {
-    await FilesystemPromises.rm(path, { recursive: true });
+	await FilesystemPromises.rm(path, { recursive: true });
 }
 async function move(src, dest, options = {}) {
-    await FsExtra.move(src, dest, options);
+	await FsExtra.move(src, dest, options);
 }
-async function readFile(path, options = { encoding: 'utf-8', flag: 'r' }) {
-    return await FilesystemPromises.readFile(path, options);
+async function readFile(path, options = {
+	encoding: "utf-8",
+	flag: "r"
+}) {
+	return await FilesystemPromises.readFile(path, options);
 }
-async function writeFile(path, data, options = { encoding: 'utf-8', flag: 'w' }) {
-    return await FilesystemPromises.writeFile(path, data, options);
+async function writeFile(path, data, options = {
+	encoding: "utf-8",
+	flag: "w"
+}) {
+	return await FilesystemPromises.writeFile(path, data, options);
 }
 async function readJsonFile(path) {
-    const content = await readFile(path, { encoding: 'utf8' });
-    return JSON.parse(content);
+	const content = await readFile(path, { encoding: "utf8" });
+	return JSON.parse(content);
 }
 async function writeJsonFile(path, data) {
-    return writeFile(path, JSON.stringify(data, null, 4));
+	return writeFile(path, JSON.stringify(data, null, 4));
 }
 async function glob(pattern, options) {
-    let _options = options;
-    if (options?.dot == null) {
-        _options = { ...options, dot: true };
-    }
-    return glob$1.glob(pattern, _options || {});
-}
-async function archived(path$1, name, glob = '**/*') {
-    return new Promise((resolve$1, reject) => {
-        try {
-            const archivePath = resolve(path$1, `${name}.zip`);
-            const output = createWriteStream(archivePath);
-            const _archiver = archiver('zip', { zlib: { level: 9 } });
-            output.on('close', () => resolve$1(archivePath));
-            _archiver.on('error', () => (err) => reject(err));
-            _archiver.pipe(output);
-            _archiver.glob(glob, {
-                ignore: [`${name}.zip`],
-                cwd: path$1,
-            });
-            _archiver.finalize();
-        }
-        catch (err) {
-            reject(err);
-        }
-    });
+	let _options = options;
+	if (options?.dot == null) _options = {
+		...options,
+		dot: true
+	};
+	return glob$1.glob(pattern, _options || {});
+}
+async function archived(path, name, glob = "**/*") {
+	return new Promise((resolve$1, reject) => {
+		try {
+			const archivePath = resolve(path, `${name}.zip`);
+			const output = createWriteStream(archivePath);
+			const _archiver = archiver("zip", { zlib: { level: 9 } });
+			output.on("close", () => resolve$1(archivePath));
+			_archiver.on("error", () => (err) => reject(err));
+			_archiver.pipe(output);
+			_archiver.glob(glob, {
+				ignore: [`${name}.zip`],
+				cwd: path
+			});
+			_archiver.finalize();
+		} catch (err) {
+			reject(err);
+		}
+	});
 }
 async function unlink(path) {
-    if (await exists(path)) {
-        await FilesystemPromises.unlink(path);
-    }
+	if (await exists(path)) await FilesystemPromises.unlink(path);
 }
 async function readdir(path) {
-    return await FilesystemPromises.readdir(path);
+	return await FilesystemPromises.readdir(path);
 }
 async function stat(path) {
-    return await FilesystemPromises.stat(path);
+	return await FilesystemPromises.stat(path);
 }
 async function chmod(path, mode) {
-    return await FilesystemPromises.chmod(path, mode);
+	return await FilesystemPromises.chmod(path, mode);
 }
 const watch = chokidar.watch;
-async function decompressGzip(file, destination, mode = 0o755) {
-    const unzip = createGunzip();
-    const readStream = createReadStream(file);
-    const writeStream = createWriteStream(destination, { mode });
-    await pipeline(readStream, unzip, writeStream);
+async function decompressGzip(file, destination, mode = 493) {
+	const unzip = createGunzip();
+	await pipeline(createReadStream(file), unzip, createWriteStream(destination, { mode }));
 }
 async function extractTar(file, cwd, mode) {
-    await tar.extract({ cwd, file, mode });
-}
-
-export { archived, chmod, decompressGzip, exists, extractTar, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };
+	await tar.extract({
+		cwd,
+		file,
+		mode
+	});
+}
+//#endregion
+export { archived, chmod, decompressGzip, exists, extractTar, filesystem_exports, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };

package/dist/node/form.js

@@ -1,45 +1,30 @@
-import { FormData, File } from 'formdata-node';
-import { fileFromPath } from 'formdata-node/file-from-path';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { File, FormData } from "formdata-node";
+import { fileFromPath } from "formdata-node/file-from-path";
+//#region lib/node/form.ts
+var form_exports = /* @__PURE__ */ __exportAll({
+	convert: () => convert,
+	file: () => file
+});
 const file = fileFromPath;
 function convert(source, form = new FormData(), parentKey = null) {
-    source = source || {};
-    for (const key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-            append(form, toKey(parentKey, key), source[key]);
-        }
-    }
-    return form;
+	source = source || {};
+	for (const key in source) if (Object.prototype.hasOwnProperty.call(source, key)) append(form, toKey(parentKey, key), source[key]);
+	return form;
 }
 function append(form, key, value) {
-    if (Array.isArray(value)) {
-        return Array.from(value.keys()).forEach(index => append(form, toKey(key, index.toString()), value[index]));
-    }
-    else if (value instanceof Date) {
-        return form.append(key, value.toISOString());
-    }
-    else if (value instanceof File) {
-        return form.append(key, value, value.name);
-    }
-    else if (value instanceof Blob) {
-        return form.append(key, value);
-    }
-    else if (typeof value === 'boolean') {
-        return form.append(key, value ? '1' : '0');
-    }
-    else if (typeof value === 'string') {
-        return form.append(key, value);
-    }
-    else if (typeof value === 'number') {
-        return form.append(key, `${value}`);
-    }
-    else if (value === null || value === undefined) {
-        return form.append(key, '');
-    }
-    convert(value, form, key);
+	if (Array.isArray(value)) return Array.from(value.keys()).forEach((index) => append(form, toKey(key, index.toString()), value[index]));
+	else if (value instanceof Date) return form.append(key, value.toISOString());
+	else if (value instanceof File) return form.append(key, value, value.name);
+	else if (value instanceof Blob) return form.append(key, value);
+	else if (typeof value === "boolean") return form.append(key, value ? "1" : "0");
+	else if (typeof value === "string") return form.append(key, value);
+	else if (typeof value === "number") return form.append(key, `${value}`);
+	else if (value === null || value === void 0) return form.append(key, "");
+	convert(value, form, key);
 }
 function toKey(parent, key) {
-    return parent ? `${parent}[${key}]` : key;
+	return parent ? `${parent}[${key}]` : key;
 }
-
-export { convert, file };
+//#endregion
+export { convert, file, form_exports };

package/dist/node/git.js

@@ -1,52 +1,47 @@
-import process from 'node:process';
-import git from 'simple-git';
-import { exec } from './system.js';
-
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { exec } from "./system.js";
+import process from "node:process";
+import git from "simple-git";
+//#region lib/node/git.ts
+var git_exports = /* @__PURE__ */ __exportAll({
+	assertGitExists: () => assertGitExists,
+	binaryExists: () => binaryExists,
+	clone: () => clone
+});
 async function binaryExists() {
-    try {
-        await exec('git', ['--version']);
-        return true;
-    }
-    catch {
-        return false;
-    }
+	try {
+		await exec("git", ["--version"]);
+		return true;
+	} catch {
+		return false;
+	}
 }
 async function assertGitExists() {
-    if (!(await binaryExists())) {
-        throw new Error('Git is required for the setup to continue.');
-    }
+	if (!await binaryExists()) throw new Error("Git is required for the setup to continue.");
 }
 async function clone(cloneOptions) {
-    await assertGitExists();
-    const { url, destination, shallow, latestTag } = cloneOptions;
-    const [repository, branch] = url.split('#');
-    const options = { '--recurse-submodules': null };
-    // ignore latest tag if branch is provided
-    if (branch) {
-        options['--branch'] = branch;
-    }
-    if (shallow && latestTag) {
-        throw new Error('Cannot get a shallow clone of the latest branch.');
-    }
-    if (shallow) {
-        options['--depth'] = 1;
-    }
-    const { GIT_ASKPASS, SSH_ASKPASS, ...env } = process.env;
-    await git({ config: [] })
-        .env({ ...env, GIT_TERMINAL_PROMPT: '0' })
-        .clone(repository, destination, options);
-    if (latestTag) {
-        const localRepo = git(destination);
-        const latestTag = await getLocalLatestTag(localRepo, url);
-        await localRepo.checkout(latestTag);
-    }
+	await assertGitExists();
+	const { url, destination, shallow, latestTag } = cloneOptions;
+	const [repository, branch] = url.split("#");
+	const options = { "--recurse-submodules": null };
+	if (branch) options["--branch"] = branch;
+	if (shallow && latestTag) throw new Error("Cannot get a shallow clone of the latest branch.");
+	if (shallow) options["--depth"] = 1;
+	const { GIT_ASKPASS, SSH_ASKPASS, ...env } = process.env;
+	await git({ config: [] }).env({
+		...env,
+		GIT_TERMINAL_PROMPT: "0"
+	}).clone(repository, destination, options);
+	if (latestTag) {
+		const localRepo = git(destination);
+		const latestTag = await getLocalLatestTag(localRepo, url);
+		await localRepo.checkout(latestTag);
+	}
 }
 async function getLocalLatestTag(repository, url) {
-    const latest = (await repository.tags()).latest;
-    if (!latest) {
-        throw new Error(`Couldn't infer the latest tag from ${url}`);
-    }
-    return latest;
+	const latest = (await repository.tags()).latest;
+	if (!latest) throw new Error(`Couldn't infer the latest tag from ${url}`);
+	return latest;
 }
-
-export { assertGitExists, binaryExists, clone };
+//#endregion
+export { assertGitExists, binaryExists, clone, git_exports };

package/dist/node/github.js

@@ -1,11 +1,14 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+//#region lib/node/github.ts
+var github_exports = /* @__PURE__ */ __exportAll({ parseRepositoryReference: () => parseRepositoryReference });
 function parseRepositoryReference(reference) {
-    const url = new URL(reference);
-    const [, user, repo, ...repoPath] = url.pathname.split('/');
-    return {
-        baseUrl: `${url.origin}/${user}/${repo}`,
-        branch: url.hash ? url.hash.slice(1) : undefined,
-        path: repoPath.length > 0 ? repoPath.join('/') : undefined,
-    };
+	const url = new URL(reference);
+	const [, user, repo, ...repoPath] = url.pathname.split("/");
+	return {
+		baseUrl: `${url.origin}/${user}/${repo}`,
+		branch: url.hash ? url.hash.slice(1) : void 0,
+		path: repoPath.length > 0 ? repoPath.join("/") : void 0
+	};
 }
-
-export { parseRepositoryReference };
+//#endregion
+export { github_exports, parseRepositoryReference };