@youcan/cli-kit 1.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 YouCan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/common/string.d.ts

@@ -0,0 +1 @@
+export declare function hyphenate(value: string): string;

package/dist/common/string.js

@@ -0,0 +1,7 @@
+import { paramCase } from 'change-case';
+
+function hyphenate(value) {
+    return paramCase(value);
+}
+
+export { hyphenate };

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * as Cli from './node/cli';
+export * as Git from './node/git';
+export * as Path from './node/path';
+export * as Tasks from './node/tasks';
+export * as Github from './node/github';
+export * as System from './node/system';
+export * as Filesystem from './node/filesystem';
+export * as String from './common/string';

package/dist/index.js

@@ -0,0 +1,16 @@
+import * as cli from './node/cli.js';
+export { cli as Cli };
+import * as git from './node/git.js';
+export { git as Git };
+import * as path from './node/path.js';
+export { path as Path };
+import * as tasks from './node/tasks.js';
+export { tasks as Tasks };
+import * as github from './node/github.js';
+export { github as Github };
+import * as system from './node/system.js';
+export { system as System };
+import * as filesystem from './node/filesystem.js';
+export { filesystem as Filesystem };
+import * as string from './common/string.js';
+export { string as String };

package/dist/internal/node/constants.d.ts

@@ -0,0 +1,4 @@
+export declare function cachedir(): string;
+export declare const envvars: {
+    env: string;
+};

package/dist/internal/node/constants.js

@@ -0,0 +1,14 @@
+import envpaths from 'env-paths';
+
+const identifier = 'youcan-cli';
+function cachedir() {
+    if (process.env.XDG_CACHE_HOME) {
+        return process.env.XDG_CACHE_HOME;
+    }
+    return envpaths(identifier).cache;
+}
+const envvars = {
+    env: 'YC_CLI_ENV',
+};
+
+export { cachedir, envvars };

package/dist/internal/node/ui.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+export declare class Loader {
+    private message;
+    timer: NodeJS.Timeout | null;
+    constructor(message: string);
+    start(): this;
+    private flush;
+    stop(): this;
+    error(message?: string | null): this;
+    static exec(message: string, closure: (loader: Loader) => Promise<void>): Promise<void>;
+}

package/dist/internal/node/ui.js

@@ -0,0 +1,45 @@
+import kleur from 'kleur';
+
+class Loader {
+    message;
+    timer;
+    constructor(message) {
+        this.message = message;
+        this.message = message;
+        this.timer = null;
+    }
+    start() {
+        process.stdout.write('\x1B[?25l');
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let i = 0;
+        this.timer = setInterval(() => {
+            process.stdout.write(`\r${frames[i = ++i % frames.length]} ${this.message}`);
+        }, 100);
+        return this;
+    }
+    flush() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    stop() {
+        this.flush();
+        process.stdout.write('\r');
+        process.stdout.write(kleur.green(`✔ ${this.message}\n`));
+        return this;
+    }
+    error(message = null) {
+        this.flush();
+        process.stdout.write('\r');
+        process.stdout.write(kleur.red(`✖ ${message ?? this.message}\n`));
+        return this;
+    }
+    static async exec(message, closure) {
+        const loader = new Loader(message).start();
+        await closure(loader);
+        loader.timer && loader.stop();
+    }
+}
+
+export { Loader };

package/dist/node/cli.d.ts

@@ -0,0 +1,17 @@
+import { Command as BaseCommand, ux } from '@oclif/core';
+import prompts from 'prompts';
+interface ExecOptions {
+    moduleUrl: string;
+    development: boolean;
+}
+export declare function exec(options: ExecOptions): Promise<void>;
+export declare function execCreate(cmdlet: string, options: ExecOptions): Promise<void>;
+export declare const commonFlags: {
+    'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+};
+export declare abstract class Command extends BaseCommand {
+    output: typeof ux;
+    prompt: typeof prompts;
+}
+export {};

package/dist/node/cli.js

@@ -0,0 +1,61 @@
+import { Flags, Command as Command$1, ux } from '@oclif/core';
+import prompts from 'prompts';
+import { truthy } from './context/helpers.js';
+import { isDevelopment } from './context/local.js';
+
+function setupEnvVars(options) {
+    if (process.argv.includes('--verbose')) {
+        process.env.DEBUG = process.env.DEBUG ?? '*';
+    }
+    if (options.development) {
+        process.env.YC_CLI_ENV ??= 'development';
+    }
+}
+function setupColorMode() {
+    if (process.argv.includes('--no-color')
+        || truthy(process.env.NO_COLOR)
+        || truthy(process.env.YC_FLAG_NO_COLOR)
+        || process.env.TERM === 'dumb') {
+        process.env.FORCE_COLOR = '0';
+    }
+}
+async function exec(options) {
+    setupEnvVars(options);
+    setupColorMode();
+    const { run, settings, flush, Errors } = await import('@oclif/core');
+    if (isDevelopment()) {
+        settings.debug = true;
+    }
+    run(undefined, options.moduleUrl)
+        .then(() => flush())
+        .catch(err => Errors.handle(err));
+}
+async function execCreate(cmdlet, options) {
+    setupEnvVars(options);
+    const initIndex = process.argv
+        .findIndex(arg => arg.includes('init'));
+    if (initIndex === -1) {
+        const initIndex = process.argv
+            .findIndex(arg => arg.match(new RegExp(`bin(\\/|\\\\)+(create-${cmdlet}|dev|exec)`))) + 1;
+        process.argv.splice(initIndex, 0, 'init');
+    }
+    await exec(options);
+}
+const commonFlags = {
+    'no-color': Flags.boolean({
+        hidden: false,
+        description: 'Disable color output.',
+        env: 'YC_FLAG_NO_COLOR',
+    }),
+    'verbose': Flags.boolean({
+        hidden: false,
+        description: 'Increase the verbosity of the logs.',
+        env: 'YC_FLAG_VERBOSE',
+    }),
+};
+class Command extends Command$1 {
+    output = ux;
+    prompt = prompts;
+}
+
+export { Command, commonFlags, exec, execCreate };

package/dist/node/context/helpers.d.ts

@@ -0,0 +1 @@
+export declare function truthy(val: string | undefined): boolean;

package/dist/node/context/helpers.js

@@ -0,0 +1,8 @@
+function truthy(val) {
+    if (!val) {
+        return false;
+    }
+    return ['1', 'true', 'TRUE', 'yes', 'YES', 'y', 'Y'].includes(val);
+}
+
+export { truthy };

package/dist/node/context/local.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare function isDevelopment(env?: NodeJS.ProcessEnv): boolean;

package/dist/node/context/local.js

@@ -0,0 +1,7 @@
+import { envvars } from '../../internal/node/constants.js';
+
+function isDevelopment(env = process.env) {
+    return env[envvars.env] === 'development';
+}
+
+export { isDevelopment };

package/dist/node/filesystem.d.ts

@@ -0,0 +1,8 @@
+export declare function exists(path: string): Promise<boolean>;
+export declare function tapIntoTmp<T>(callback: (tmp: string) => T | Promise<T>): Promise<T>;
+export declare function mkdir(path: string): Promise<void>;
+interface MoveFileOptions {
+    overwrite?: boolean;
+}
+export declare function move(src: string, dest: string, options?: MoveFileOptions): Promise<void>;
+export {};

package/dist/node/filesystem.js

@@ -0,0 +1,24 @@
+import FilesystemPromises from 'node:fs/promises';
+import { temporaryDirectoryTask } from 'tempy';
+import FsExtra from 'fs-extra';
+
+async function exists(path) {
+    try {
+        await FilesystemPromises.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function tapIntoTmp(callback) {
+    return temporaryDirectoryTask(callback);
+}
+async function mkdir(path) {
+    await FilesystemPromises.mkdir(path, { recursive: true });
+}
+async function move(src, dest, options = {}) {
+    await FsExtra.move(src, dest, options);
+}
+
+export { exists, mkdir, move, tapIntoTmp };

package/dist/node/git.d.ts

@@ -0,0 +1,10 @@
+export declare function binaryExists(): Promise<boolean>;
+export interface CloneOptions {
+    url: string;
+    destination: string;
+    progressUpdater?: (statusString: string) => void;
+    shallow?: boolean;
+    latestTag?: boolean;
+}
+export declare function assertGitExists(): Promise<void>;
+export declare function clone(cloneOptions: CloneOptions): Promise<void>;

package/dist/node/git.js

@@ -0,0 +1,52 @@
+import git from 'simple-git';
+import { exec } from './system.js';
+
+async function binaryExists() {
+    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.');
+    }
+}
+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 simpleGitOptions = {
+        config: ['core.askpass=true'],
+    };
+    await git(simpleGitOptions)
+        .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;
+}
+
+export { assertGitExists, binaryExists, clone };

package/dist/node/github.d.ts

@@ -0,0 +1,6 @@
+export interface RepositoryReference {
+    baseUrl: string;
+    branch?: string;
+    path?: string;
+}
+export declare function parseRepositoryReference(reference: string): RepositoryReference;

package/dist/node/github.js

@@ -0,0 +1,11 @@
+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,
+    };
+}
+
+export { parseRepositoryReference };

package/dist/node/path.d.ts

@@ -0,0 +1,3 @@
+export declare function resolve(...paths: string[]): string;
+export declare function cwd(): string;
+export declare function join(...paths: string[]): string;

package/dist/node/path.js

@@ -0,0 +1,13 @@
+import path from 'node:path';
+
+function resolve(...paths) {
+    return path.resolve(...paths);
+}
+function cwd() {
+    return path.normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
+}
+function join(...paths) {
+    return path.join(...paths);
+}
+
+export { cwd, join, resolve };

package/dist/node/system.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Readable, Writable } from 'stream';
+export interface ExecOptions {
+    cwd?: string;
+    env?: {
+        [key: string]: string | undefined;
+    };
+    stdin?: Readable | 'inherit';
+    stdout?: Writable | 'inherit';
+    stderr?: Writable | 'inherit';
+    stdio?: 'inherit';
+    input?: string;
+    signal?: AbortSignal;
+    errorHandler?: (error: unknown) => Promise<void>;
+}
+export declare function exec(command: string, args: string[], options?: ExecOptions): Promise<void>;

package/dist/node/system.js

@@ -0,0 +1,47 @@
+import { execa } from 'execa';
+
+function buildExec(command, args, options) {
+    const env = options?.env ?? process.env;
+    const commandProcess = execa(command, args, {
+        env,
+        cwd: options?.cwd,
+        input: options?.input,
+        stdio: options?.stdio,
+        stdin: options?.stdin,
+        stdout: options?.stdout === 'inherit' ? 'inherit' : undefined,
+        stderr: options?.stderr === 'inherit' ? 'inherit' : undefined,
+        windowsHide: false,
+    });
+    return commandProcess;
+}
+async function exec(command, args, options) {
+    const commandProcess = buildExec(command, args, options);
+    if (options?.stderr && options.stderr !== 'inherit') {
+        commandProcess.stderr?.pipe(options.stderr, { end: false });
+    }
+    if (options?.stdout && options.stdout !== 'inherit') {
+        commandProcess.stdout?.pipe(options.stdout, { end: false });
+    }
+    let aborted = false;
+    options?.signal?.addEventListener('abort', () => {
+        const pid = commandProcess.pid;
+        if (pid) {
+            aborted = true;
+        }
+    });
+    try {
+        await commandProcess;
+    }
+    catch (err) {
+        if (aborted) {
+            return;
+        }
+        if (options?.errorHandler) {
+            await options?.errorHandler(err);
+            return;
+        }
+        throw err;
+    }
+}
+
+export { exec };

package/dist/node/tasks.d.ts

@@ -0,0 +1,7 @@
+export interface Task<T = unknown> {
+    title: string;
+    errors?: Error[];
+    skip?: (ctx: T) => boolean;
+    task: (context: T, task: Task<T>) => Promise<void | Task<T>[]>;
+}
+export declare function run<T = unknown>(tasks: Task[]): Promise<void>;

package/dist/node/tasks.js

@@ -0,0 +1,30 @@
+import { Loader } from '../internal/node/ui.js';
+
+async function runTask(task, ctx) {
+    if (task.skip?.(ctx)) {
+        return;
+    }
+    return await task.task(ctx, task);
+}
+async function run(tasks) {
+    const context = {};
+    for (const task of tasks) {
+        await Loader.exec(task.title, async (loader) => {
+            try {
+                const subtasks = await runTask(task, context);
+                if (Array.isArray(subtasks) && subtasks.length > 0 && subtasks.every(t => 'task' in t)) {
+                    for (const subtask of subtasks) {
+                        await runTask(subtask, context);
+                    }
+                }
+                loader.stop();
+            }
+            catch (err) {
+                loader.error(String(err));
+                throw err;
+            }
+        });
+    }
+}
+
+export { run };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@youcan/cli-kit",
+  "type": "module",
+  "version": "1.1.0-beta.0",
+  "description": "Utilities for the YouCan CLI",
+  "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
+  "license": "MIT",
+  "keywords": [
+    "youcan",
+    "youcan-cli",
+    "youcan-app"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@oclif/core": "^2.15.0",
+    "change-case": "^4.1.2",
+    "env-paths": "^3.0.0",
+    "execa": "^6.1.0",
+    "fs-extra": "^11.1.1",
+    "kleur": "^4.1.5",
+    "prompts": "^2.4.2",
+    "simple-git": "^3.20.0",
+    "tempy": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.2",
+    "@types/node": "^18.18.0",
+    "@types/prompts": "^2.4.5",
+    "shx": "^0.3.4"
+  },
+  "scripts": {
+    "build": "shx rm -rf dist && tsc --noEmit && rollup --config rollup.config.js",
+    "dev": "rollup --config rollup.config.js --watch",
+    "release": "pnpm publish --access public",
+    "type-check": "tsc --noEmit"
+  }
+}