@nocobase/cli 2.1.0-beta.33 → 2.1.0-beta.35

package/dist/lib/inquirer.js

@@ -0,0 +1,244 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { cursorTo } from '@inquirer/ansi';
+import pc from 'picocolors';
+import { createPrompt, isBackspaceKey, isEnterKey, makeTheme, useEffect, useKeypress, usePrefix, useState, } from '@inquirer/core';
+let confirmModulePromise;
+let selectModulePromise;
+function loadConfirmModule() {
+    confirmModulePromise ??= import('@inquirer/confirm');
+    return confirmModulePromise;
+}
+function loadSelectModule() {
+    selectModulePromise ??= import('@inquirer/select');
+    return selectModulePromise;
+}
+export function buildPlainMessageTheme(extra) {
+    return {
+        ...extra,
+        style: {
+            ...extra?.style,
+            message: (text) => text,
+        },
+    };
+}
+function buildSelectAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function buildConfirmAnswer(text) {
+    return `\n${pc.cyan('❯')} ${pc.cyan(text)}`;
+}
+function isFullWidthCodePoint(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1f300 && codePoint <= 0x1f64f) ||
+            (codePoint >= 0x1f900 && codePoint <= 0x1f9ff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}
+function stringWidth(value) {
+    let width = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null)
+            continue;
+        if (codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f))
+            continue;
+        width += isFullWidthCodePoint(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+function stripAnsi(value) {
+    return value.replace(new RegExp(String.raw `\\u001B\\[[0-9;]*m`, 'g'), '');
+}
+function lastLineWidth(value) {
+    const lines = stripAnsi(value).split('\n');
+    return stringWidth(lines[lines.length - 1] ?? '');
+}
+function resolveRequiredError(required) {
+    if (typeof required === 'string') {
+        return required;
+    }
+    return '此项为必填';
+}
+function hasUsableDefault(value) {
+    return value != null && value !== '';
+}
+function buildIdleHint(config) {
+    const placeholder = config.placeholder?.trim();
+    if (placeholder) {
+        return placeholder;
+    }
+    return '';
+}
+function buildInputLine(value) {
+    return `${pc.cyan('❯')} ${value}`;
+}
+function buildErrorLine(error) {
+    return pc.red(`✖ ${error}`);
+}
+export const input = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [defaultValue, setDefaultValue] = useState(config.default ?? '');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useEffect((rl) => {
+        if (config.default) {
+            rl.write(config.default);
+            setValue(config.default);
+        }
+    }, []);
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (isBackspaceKey(key) && !value) {
+            setDefaultValue('');
+            return;
+        }
+        if (isBackspaceKey(key)) {
+            setValue(rl.line.slice(0, -1));
+            setError(undefined);
+            return;
+        }
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value || defaultValue;
+        setStatus('loading');
+        if (!answer && config.required) {
+            rl.write(value);
+            setError(resolveRequiredError(config.required));
+            setStatus('idle');
+            return;
+        }
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const isTyping = value.length > 0;
+    const hasDefault = hasUsableDefault(defaultValue);
+    const idleHint = buildIdleHint(config);
+    const showIdleHint = !isTyping && status === 'idle' && idleHint !== '';
+    const showDefaultValue = !isTyping && status === 'idle' && hasDefault;
+    const displayValue = status === 'done'
+        ? theme.style.answer(value)
+        : isTyping
+            ? value
+            : showDefaultValue
+                ? defaultValue
+                : showIdleHint
+                    ? pc.dim(idleHint)
+                    : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    const promptWithCursorFix = showIdleHint
+        ? prompt + cursorTo(lastLineWidth(buildInputLine('')))
+        : showDefaultValue
+            ? prompt + cursorTo(lastLineWidth(buildInputLine(defaultValue)))
+            : prompt;
+    return [promptWithCursorFix, error ? buildErrorLine(error) : ''];
+});
+export async function confirm(options) {
+    const module = await loadConfirmModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildConfirmAnswer,
+            },
+            ...options.theme,
+        }),
+        transformer: options.transformer ?? ((value) => (value ? 'Yes' : 'No')),
+    });
+}
+export async function select(options) {
+    const module = await loadSelectModule();
+    return module.default({
+        ...options,
+        theme: buildPlainMessageTheme({
+            style: {
+                answer: buildSelectAnswer,
+            },
+            ...options.theme,
+        }),
+    });
+}
+function resolveMaskChar(mask) {
+    if (typeof mask === 'string') {
+        return mask;
+    }
+    if (mask === false) {
+        return '';
+    }
+    return '•';
+}
+export const password = createPrompt((config, done) => {
+    const theme = makeTheme(config.theme);
+    const [status, setStatus] = useState('idle');
+    const [value, setValue] = useState('');
+    const [error, setError] = useState();
+    const prefix = usePrefix({ status, theme });
+    useKeypress(async (key, rl) => {
+        if (status !== 'idle')
+            return;
+        if (!isEnterKey(key)) {
+            setValue(rl.line);
+            setError(undefined);
+            return;
+        }
+        const answer = value;
+        setStatus('loading');
+        if (config.validate) {
+            const result = await config.validate(answer);
+            if (result !== true) {
+                rl.write(value);
+                setError(typeof result === 'string' ? result : 'Invalid input');
+                setStatus('idle');
+                return;
+            }
+        }
+        setValue(answer);
+        setStatus('done');
+        done(answer);
+    });
+    const message = theme.style.message(config.message, status);
+    const maskChar = resolveMaskChar(config.mask);
+    const displayValue = status === 'done'
+        ? theme.style.answer(maskChar.repeat(value.length))
+        : maskChar
+            ? maskChar.repeat(value.length)
+            : '';
+    const headerLine = [prefix, message].filter(Boolean).join(' ');
+    const inputLine = buildInputLine(displayValue);
+    const prompt = headerLine.endsWith('\n') ? `${headerLine}${inputLine}` : `${headerLine}\n${inputLine}`;
+    return [prompt, error ? buildErrorLine(error) : ''];
+});

package/dist/lib/object-utils.js

@@ -0,0 +1,76 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+export function pickKeys(object, keys) {
+    const picked = {};
+    for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            const typedKey = key;
+            picked[typedKey] = object[typedKey];
+        }
+    }
+    return picked;
+}
+export function omitKeys(object, keys) {
+    const omittedKeys = new Set(keys);
+    const result = {};
+    for (const key of Object.keys(object)) {
+        if (!omittedKeys.has(key)) {
+            const typedKey = key;
+            result[typedKey] = object[typedKey];
+        }
+    }
+    return result;
+}
+export function upperFirst(value) {
+    if (!value) {
+        return value;
+    }
+    return value[0].toUpperCase() + value.slice(1);
+}
+export function deepEqual(left, right) {
+    if (Object.is(left, right)) {
+        return true;
+    }
+    if (left == null || right == null) {
+        return false;
+    }
+    if (typeof left !== typeof right) {
+        return false;
+    }
+    if (typeof left !== 'object') {
+        return false;
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) {
+            return false;
+        }
+        for (let index = 0; index < left.length; index += 1) {
+            if (!deepEqual(left[index], right[index])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const leftObject = left;
+    const rightObject = right;
+    const leftKeys = Object.keys(leftObject);
+    const rightKeys = Object.keys(rightObject);
+    if (leftKeys.length !== rightKeys.length) {
+        return false;
+    }
+    for (const key of leftKeys) {
+        if (!Object.prototype.hasOwnProperty.call(rightObject, key)) {
+            return false;
+        }
+        if (!deepEqual(leftObject[key], rightObject[key])) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/lib/prompt-catalog-core.js

@@ -0,0 +1,185 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { createCliTranslate, resolveCliLocale, resolveLocalizedText, } from "./cli-locale.js";
+export function selectOptionValues(options) {
+    return options.map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function resolvePromptText(text, locale, fallback = '') {
+    return resolveLocalizedText(text, { locale, fallback });
+}
+export function enabledSelectOptionValues(options) {
+    return options
+        .filter((o) => typeof o === 'string' || o.disabled !== true)
+        .map((o) => (typeof o === 'string' ? o : o.value));
+}
+export function createPromptCatalogHooks(locale, overrides, defaults) {
+    return {
+        onCancel: overrides?.onCancel
+            ?? defaults?.onCancel
+            ?? (() => {
+                throw new Error(createCliTranslate(locale)('promptCatalog.common.cancelled'));
+            }),
+        onMissingNonInteractive: overrides?.onMissingNonInteractive
+            ?? defaults?.onMissingNonInteractive
+            ?? ((message) => {
+                throw new Error(message);
+            }),
+    };
+}
+export function hasIvKey(iv, key) {
+    return (Object.prototype.hasOwnProperty.call(iv, key) && iv[key] !== undefined && iv[key] !== null);
+}
+export function resolveTextInitial(def, valuesSoFar) {
+    const iv = def.initialValue;
+    if (typeof iv === 'function') {
+        return iv(valuesSoFar);
+    }
+    return iv;
+}
+export function mergedText(key, def, iv, useYesInitial, valuesSoFar = {}) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return resolveTextInitial(def, valuesSoFar) ?? '';
+}
+export function mergedBoolean(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return Boolean(iv[key]);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue ?? true;
+}
+export function mergedSelect(key, def, iv, useYesInitial) {
+    const enabledValueList = enabledSelectOptionValues(def.options);
+    if (hasIvKey(iv, key)) {
+        const s = String(iv[key]);
+        if (enabledValueList.includes(s)) {
+            return s;
+        }
+        return undefined;
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined && enabledValueList.includes(def.yesInitialValue)) {
+        return def.yesInitialValue;
+    }
+    const d = def.initialValue;
+    if (d !== undefined && enabledValueList.includes(d)) {
+        return d;
+    }
+    return enabledValueList[0];
+}
+export function mergedInteger(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        const v = iv[key];
+        return typeof v === 'number' ? v : Number.parseInt(String(v), 10);
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+export function mergedPassword(key, def, iv, useYesInitial) {
+    if (hasIvKey(iv, key)) {
+        return String(iv[key] ?? '');
+    }
+    if (useYesInitial && def.yesInitialValue !== undefined) {
+        return def.yesInitialValue;
+    }
+    return def.initialValue;
+}
+export function isBlankText(value) {
+    return value.trim() === '';
+}
+export async function runPromptFieldValidate(def, value, values) {
+    if (def.type === 'intro' || def.type === 'outro' || def.type === 'run') {
+        return undefined;
+    }
+    if (!('validate' in def) || def.validate === undefined) {
+        return undefined;
+    }
+    const r = await def.validate(value, values);
+    if (r == null || r === '') {
+        return undefined;
+    }
+    return String(r);
+}
+export function isPromptBlockSkipped(def, values) {
+    if (def.type === 'run') {
+        return def.when !== undefined && !def.when(values);
+    }
+    return def.hidden !== undefined && def.hidden(values);
+}
+export function tryApplyPreset(key, def, preset, out, hooks, locale) {
+    const t = createCliTranslate(locale);
+    if (!hasIvKey(preset, key)) {
+        return false;
+    }
+    const raw = preset[key];
+    switch (def.type) {
+        case 'intro':
+        case 'outro':
+        case 'run':
+            return false;
+        case 'text': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'boolean': {
+            out[key] = Boolean(raw);
+            return true;
+        }
+        case 'select': {
+            const valueList = selectOptionValues(def.options);
+            const s = String(raw ?? '');
+            if (!valueList.includes(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidSelect', { key, value: s, options: valueList.join(', ') }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'password': {
+            const s = String(raw ?? '');
+            if (def.required && isBlankText(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+            }
+            out[key] = s;
+            return true;
+        }
+        case 'integer': {
+            if (typeof raw === 'number' && Number.isFinite(raw)) {
+                out[key] = raw;
+                return true;
+            }
+            const s = String(raw ?? '').trim();
+            if (s === '') {
+                if (def.required) {
+                    hooks.onMissingNonInteractive(t('promptCatalog.preset.required', { key }));
+                }
+                out[key] = def.initialValue ?? 0;
+                return true;
+            }
+            if (!/^-?\\d+$/.test(s)) {
+                hooks.onMissingNonInteractive(t('promptCatalog.preset.invalidInteger', { key }));
+            }
+            out[key] = Number.parseInt(s, 10);
+            return true;
+        }
+    }
+}
+export function resolvePromptCatalogLocale(locale) {
+    return resolveCliLocale(locale);
+}