@youcan/cli-kit 2.1.4 → 2.3.0

package/dist/common/string.d.ts

@@ -1,2 +1,2 @@
-export declare function hyphenate(value: string): string;
-export declare function isJson(subject: string): boolean;
+export declare function hyphenate(value: string): string;
+export declare function isJson(subject: string): boolean;

package/dist/common/string.js

@@ -1,16 +1,16 @@
 import { paramCase } from 'change-case';
 
-function hyphenate(value) {
-    return paramCase(value);
-}
-function isJson(subject) {
-    try {
-        JSON.parse(subject);
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
+function hyphenate(value) {
+    return paramCase(value);
+}
+function isJson(subject) {
+    try {
+        JSON.parse(subject);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
 }
 
 export { hyphenate, isJson };

package/dist/index.d.ts

@@ -1,17 +1,19 @@
-export * as Cli from './node/cli';
-export * as Git from './node/git';
-export * as Env from './node/env';
-export * as Path from './node/path';
-export * as Http from './node/http';
-export * as Form from './node/form';
-export * as Tasks from './node/tasks';
-export * as Github from './node/github';
-export * as System from './node/system';
-export * as Config from './node/config';
-export * as Crypto from './node/crypto';
-export * as Worker from './node/worker';
-export * as Session from './node/session';
-export * as Callback from './node/callback';
-export * as Filesystem from './node/filesystem';
-export * as String from './common/string';
-export { default as Color } from 'kleur';
+export * as Cli from './node/cli';
+export * as Git from './node/git';
+export * as Env from './node/env';
+export * as Path from './node/path';
+export * as Http from './node/http';
+export * as Form from './node/form';
+export * as Tasks from './node/tasks';
+export * as Github from './node/github';
+export * as System from './node/system';
+export * as Config from './node/config';
+export * as Crypto from './node/crypto';
+export * as Worker from './node/worker';
+export * as Session from './node/session';
+export * as Callback from './node/callback';
+export * as Filesystem from './node/filesystem';
+export * as UI from './ui';
+export * as Services from './services';
+export * as String from './common/string';
+export { default as Color } from 'kleur';

package/dist/index.js

@@ -28,6 +28,10 @@ import * as callback from './node/callback.js';
 export { callback as Callback };
 import * as filesystem from './node/filesystem.js';
 export { filesystem as Filesystem };
+import * as index from './ui/index.js';
+export { index as UI };
+import * as index$1 from './services/index.js';
+export { index$1 as Services };
 import * as string from './common/string.js';
 export { string as String };
 export { default as Color } from 'kleur';

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

@@ -1,5 +1,5 @@
-export declare function cachedir(): string;
-export declare const ENV_VARS: {
-    ENV: string;
-    HOST_ENV: string;
-};
+export declare function cachedir(): string;
+export declare const ENV_VARS: {
+    ENV: string;
+    HOST_ENV: string;
+};

package/dist/internal/node/constants.js

@@ -1,15 +1,15 @@
 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 ENV_VARS = {
-    ENV: 'YC_CLI_ENV',
-    HOST_ENV: 'YC_CLI_HOST_ENV',
+const identifier = 'youcan-cli';
+function cachedir() {
+    if (process.env.XDG_CACHE_HOME) {
+        return process.env.XDG_CACHE_HOME;
+    }
+    return envpaths(identifier).cache;
+}
+const ENV_VARS = {
+    ENV: 'YC_CLI_ENV',
+    HOST_ENV: 'YC_CLI_HOST_ENV',
 };
 
 export { ENV_VARS, cachedir };

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

@@ -1,11 +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>;
-}
+/// <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

@@ -1,45 +1,46 @@
 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();
-    }
+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() {
+        process.stdout.write('\x1B[?25h');
+        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/callback.d.ts

@@ -1,5 +1,5 @@
-import type { Cli } from '..';
-export declare function listen(command: Cli.Command, host: string, port: number, url: string): Promise<{
-    code: string;
-    state: string;
-}>;
+import type { Cli } from '..';
+export declare function listen(command: Cli.Command, host: string, port: number, url: string): Promise<{
+    code: string;
+    state: string;
+}>;

package/dist/node/callback.js

@@ -1,58 +1,58 @@
 import { createServer } from 'node:http';
 
-class CallbackListener {
-    port;
-    host;
-    server;
-    constructor(options) {
-        this.port = options.port;
-        this.host = options.host;
-        this.server = this.create(options.callback);
-    }
-    start() {
-        this.server.listen({ port: this.port, host: this.host }, () => { });
-    }
-    stop() {
-        this.server.close();
-    }
-    create(callback) {
-        const server = async (request, response) => {
-            const respond = async (contents, error, state, code) => {
-                response.write(contents);
-                response.end();
-                return callback(this, error, state, code);
-            };
-            const query = new URL(request.url, `http://${request.headers.host}`).searchParams;
-            if (!query.has('code')) {
-                return respond('missing code in authorization callback');
-            }
-            if (!query.has('state')) {
-                return respond('missing state in authorization callback');
-            }
-            return respond('Successfully authenticated, you can now close this window.', undefined, query.get('code'), query.get('state'));
-        };
-        return createServer(server);
-    }
-}
-async function listen(command, host, port, url) {
-    return await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            command.output.info('Auto-open timed out, click below to open the login page:');
-            command.output.url('Log in to YouCan Partners', url);
-        }, 10_000);
-        const callback = (listener, error, code, state) => {
-            clearTimeout(timeout);
-            setTimeout(() => {
-                listener.stop();
-                if (error) {
-                    return reject(error);
-                }
-                return resolve({ code: code, state: state });
-            }, 500);
-        };
-        const listener = new CallbackListener({ host, port, callback });
-        listener.start();
-    });
+class CallbackListener {
+    port;
+    host;
+    server;
+    constructor(options) {
+        this.port = options.port;
+        this.host = options.host;
+        this.server = this.create(options.callback);
+    }
+    start() {
+        this.server.listen({ port: this.port, host: this.host }, () => { });
+    }
+    stop() {
+        this.server.close();
+    }
+    create(callback) {
+        const server = async (request, response) => {
+            const respond = async (contents, error, state, code) => {
+                response.write(contents);
+                response.end();
+                return callback(this, error, state, code);
+            };
+            const query = new URL(request.url, `http://${request.headers.host}`).searchParams;
+            if (!query.has('code')) {
+                return respond('missing code in authorization callback');
+            }
+            if (!query.has('state')) {
+                return respond('missing state in authorization callback');
+            }
+            return respond('Successfully authenticated, you can now close this window.', undefined, query.get('code'), query.get('state'));
+        };
+        return createServer(server);
+    }
+}
+async function listen(command, host, port, url) {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            command.output.info('Auto-open timed out, click below to open the login page:');
+            command.output.url('Log in to YouCan Partners', url);
+        }, 10_000);
+        const callback = (listener, error, code, state) => {
+            clearTimeout(timeout);
+            setTimeout(() => {
+                listener.stop();
+                if (error) {
+                    return reject(error);
+                }
+                return resolve({ code: code, state: state });
+            }, 500);
+        };
+        const listener = new CallbackListener({ host, port, callback });
+        listener.start();
+    });
 }
 
 export { listen };

package/dist/node/cli.d.ts

@@ -1,21 +1,25 @@
-/// <reference types="node" />
-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;
-    controller: AbortController;
-    clear(): void;
-    exit(code?: number | undefined): never;
-}
-export {};
+/// <reference types="node" />
+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;
+    controller: AbortController;
+    clear(): void;
+    exit(code?: number): never;
+}
+export declare class CommandError extends Error {
+    readonly suggestions?: string[] | undefined;
+    constructor(message: string, suggestions?: string[] | undefined);
+}
+export {};

package/dist/node/cli.js

@@ -1,69 +1,104 @@
 import { Flags, Command as Command$1, ux } from '@oclif/core';
 import prompts from 'prompts';
+import 'simple-git';
+import 'find-process';
+import 'tcp-port-used';
+import 'execa';
+import 'env-paths';
+import 'node-fetch';
+import 'ramda';
+import 'change-case';
+import 'formdata-node';
+import 'formdata-node/file-from-path';
+import 'kleur';
+import 'conf';
+import 'dayjs';
+import './filesystem.js';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
+import { renderError } from '../ui/components/Error.js';
 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;
-    controller = new AbortController();
-    clear() {
-        console.clear();
-    }
-    exit(code) {
-        this.controller.abort();
-        return super.exit(code);
-    }
+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';
+    }
+}
+function errorHandler(error) {
+    let suggestions = ['Run the command again'];
+    const message = error.message;
+    if (error instanceof CommandError && error.suggestions) {
+        suggestions = error.suggestions;
+    }
+    renderError({ message, suggestions });
+    process.exit(1);
+}
+async function exec(options) {
+    setupEnvVars(options);
+    setupColorMode();
+    const { run, settings, flush } = await import('@oclif/core');
+    if (isDevelopment()) {
+        settings.debug = true;
+    }
+    run(undefined, options.moduleUrl)
+        .then(() => flush())
+        .catch(errorHandler);
+}
+process.on('uncaughtException', errorHandler);
+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;
+    controller = new AbortController();
+    clear() {
+        console.clear();
+    }
+    exit(code) {
+        this.controller.abort();
+        return process.exit(code);
+    }
+}
+class CommandError extends Error {
+    suggestions;
+    constructor(message, suggestions) {
+        super(message);
+        this.suggestions = suggestions;
+    }
 }
 
-export { Command, commonFlags, exec, execCreate };
+export { Command, CommandError, commonFlags, exec, execCreate };

package/dist/node/config.d.ts

@@ -1,20 +1,20 @@
-declare class Manager<T extends {
-    [key: string]: any;
-}> {
-    private readonly store;
-    constructor(options: {
-        projectName?: string;
-        cwd?: string;
-    });
-    get<TKey extends keyof T>(key: TKey): T[TKey];
-    set<TKey extends keyof T>(key: TKey, value?: T[TKey]): void;
-    delete<TKey extends keyof T>(key: TKey): void;
-    clear(): void;
-}
-export declare function manager(options: {
-    projectName?: string;
-    cwd?: string;
-}): Manager<{
-    [key: string]: any;
-}>;
-export {};
+declare class Manager<T extends {
+    [key: string]: any;
+}> {
+    private readonly store;
+    constructor(options: {
+        projectName?: string;
+        cwd?: string;
+    });
+    get<TKey extends keyof T>(key: TKey): T[TKey];
+    set<TKey extends keyof T>(key: TKey, value?: T[TKey]): void;
+    delete<TKey extends keyof T>(key: TKey): void;
+    clear(): void;
+}
+export declare function manager(options: {
+    projectName?: string;
+    cwd?: string;
+}): Manager<{
+    [key: string]: any;
+}>;
+export {};