@mirta/cli 0.3.5 → 0.4.0

package/dist/github.mjs

@@ -1,135 +0,0 @@
-import p from 'prompts';
-import { r as runCommandAsync } from './shell.mjs';
-
-class PromptCanceledError extends Error {
-    constructor() {
-        super();
-        // Убедимся, что экземпляр имеет правильный прототип
-        Object.setPrototypeOf(this, PromptCanceledError.prototype);
-        this.name = 'PromptCanceledError';
-        Error.captureStackTrace(this, PromptCanceledError);
-    }
-}
-/**
- * @param {import('prompts').PromptObject<string> | Array<import('prompts').PromptObject<string>>} questions
- * @param {import('prompts').Options} options
- */
-async function prompts(questions, options) {
-    const po = {
-        onCancel: () => {
-            throw new PromptCanceledError();
-        },
-    };
-    return await p(questions, po);
-}
-
-const baseUrl = 'https://api.github.com/repos';
-/** Класс ошибки уровня Git. */
-class GitError extends Error {
-    constructor(message) {
-        super(message);
-        // Убедимся, что экземпляр имеет правильный прототип
-        Object.setPrototypeOf(this, GitError.prototype);
-        this.name = 'GitError';
-        this.message = message;
-        Error.captureStackTrace(this, GitError);
-    }
-}
-/** Класс ошибки уровня взаимодействия GitHub. */
-class GithubError extends Error {
-    constructor(message) {
-        super(message);
-        // Убедимся, что экземпляр имеет правильный прототип
-        Object.setPrototypeOf(this, GithubError.prototype);
-        this.name = 'GithubError';
-        this.message = message;
-        Error.captureStackTrace(this, GithubError);
-    }
-}
-/** Класс ошибки уровня GitHub Workflow. */
-class WorkflowStatusError extends Error {
-    constructor(message) {
-        super(message);
-        // Убедимся, что экземпляр имеет правильный прототип
-        Object.setPrototypeOf(this, WorkflowStatusError.prototype);
-        this.name = 'WorkflowStatusError';
-        this.message = message;
-        Error.captureStackTrace(this, WorkflowStatusError);
-    }
-}
-/** Определяет, находится ли текущее решение в рабочем дереве Git. */
-async function checkIsInWorkTreeAsync() {
-    try {
-        const { stdout } = await runCommandAsync('git', ['rev-parse', '--is-inside-work-tree'], { stdio: 'pipe' });
-        return stdout === 'true';
-    }
-    catch {
-        return false;
-    }
-}
-const getConnectionType = (url) => {
-    if (url.startsWith('git@'))
-        return 'ssh';
-    if (url.startsWith('https://'))
-        return 'https';
-};
-/** Возвращает имя репозитория и тип подключения. */
-async function getRepositoryDetails() {
-    const { stdout, stderr } = await runCommandAsync('git', ['config', 'remote.origin.url'], { stdio: 'pipe' });
-    if (stderr)
-        throw new GitError(stderr);
-    // Match the URLs like:
-    // git@github.com:wb-mirta/core.git
-    // https://github.com/wb-mirta/core.git
-    //
-    const regex = /^(?:git@|https:\/\/)(?:[^/:]+)[/:]?(.*?).git$/i;
-    const match = regex
-        .exec(stdout);
-    if (!match?.[1])
-        throw new GitError(`Unable to detect remote origin url`);
-    return {
-        name: match[1],
-        connectionType: getConnectionType(stdout),
-    };
-}
-/** Возвращает SHA текущего HEAD. */
-async function getShaAsync() {
-    return (await runCommandAsync('git', ['rev-parse', 'HEAD'])).stdout;
-}
-/** Возвращает имя текущей ветки. */
-async function getBranchAsync() {
-    return (await runCommandAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout;
-}
-/** Проверяет, синхронизирован ли текущий HEAD с удаленным. */
-async function assertIsSyncedWithRemoteAsync(repository) {
-    let isSynced = false;
-    try {
-        const branch = await getBranchAsync();
-        const remote = await fetch(`${baseUrl}/${repository}/commits/${branch}?per_page=1`);
-        const data = await remote.json();
-        isSynced = data.sha === await getShaAsync();
-    }
-    catch {
-        throw new GithubError('Failed to check whether local HEAD is up-to-date with remote');
-    }
-    if (!isSynced)
-        throw new GithubError('Local HEAD is not up-to-date with remote');
-}
-/** Проверяет успешность CI-построения последнего коммита. */
-async function assertWorkflowResultAsync(repository, name) {
-    let isBuildPassed = false;
-    try {
-        const sha = await getShaAsync();
-        const result = await fetch(`${baseUrl}/${repository}/actions/runs?head_sha=${sha}&status=completed&exclude_pull_requests=true`);
-        const data = await result.json();
-        isBuildPassed = data.workflow_runs.some(({ name: workflowName, conclusion }) => workflowName.toLowerCase() === name.toLowerCase()
-            && conclusion === 'success');
-    }
-    catch {
-        throw new GithubError('Unable to get CI status for the current commit');
-    }
-    if (!isBuildPassed)
-        throw new WorkflowStatusError('CI build of the latest commit has not passed yet');
-}
-
-export { GitError as G, PromptCanceledError as P, WorkflowStatusError as W, GithubError as a, assertIsSyncedWithRemoteAsync as b, checkIsInWorkTreeAsync as c, assertWorkflowResultAsync as d, getRepositoryDetails as g, prompts as p };

package/dist/locales/en-US.json

@@ -1,21 +0,0 @@
-{
-  "validation": {
-    "required": "Must be provided"
-  },
-  "status": {
-    "info": "Info",
-    "note": "Note",
-    "success": "Success",
-    "warn": "Warn",
-    "error": "Error",
-    "canceled": "Canceled"
-  },
-  "accent": {
-    "recommended": "(recommended)",
-    "ifConfigured": "(if configured)"
-  },
-  "errors": {
-    "operationCanceled": "Operation canceled",
-    "rootIsNotRelative": "Location is out of working directory"
-  }
-}

package/dist/locales/ru-RU.json

@@ -1,21 +0,0 @@
-{
-  "validation": {
-    "required": "Требуется указать значение"
-  },
-  "status": {
-    "info": "Инфо",
-    "note": "Примечание",
-    "success": "Успешно",
-    "warn": "Внимание",
-    "error": "Ошибка",
-    "canceled": "Отменено"
-  },
-  "accent": {
-    "recommended": "(рекомендуется)",
-    "ifConfigured": "(если настроен)"
-  },
-  "errors": {
-    "operationCanceled": "Операция прервана",
-    "rootIsNotRelative": "Расположение находится вне рабочей директории"
-  }
-}

package/dist/shell.mjs

@@ -1,189 +0,0 @@
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { existsSync, promises } from 'node:fs';
-import { resolve } from 'node:path';
-import merge from 'lodash.merge';
-import chalk from 'chalk';
-
-const fallbackLocale = 'en-US';
-const localesPath = './locales';
-let currentLocale = '';
-/**
- *
- * Used to link obtained locale with correct locale file.
- *
- * @param locale Obtained locale
- * @returns locale that linked with correct name
- */
-function linkLocale(locale) {
-    if (locale === 'C')
-        return fallbackLocale;
-    let linkedLocale;
-    try {
-        linkedLocale = Intl.getCanonicalLocales(locale)[0];
-    }
-    catch (error) {
-        console.warn(`${JSON.stringify(error)}, invalid language tag: "${locale}"`);
-    }
-    switch (linkedLocale) {
-        default:
-            linkedLocale = locale;
-    }
-    return linkedLocale;
-}
-function getLocale() {
-    if (currentLocale)
-        return currentLocale;
-    const shellLocale = process.env.LC_ALL
-        ?? process.env.LC_MESSAGES
-        ?? process.env.LANG
-        ?? Intl.DateTimeFormat().resolvedOptions().locale;
-    return currentLocale = linkLocale(shellLocale.split('.')[0].replace('_', '-'));
-}
-async function loadLanguageFile(filePath) {
-    return await promises.readFile(filePath, 'utf-8').then((content) => {
-        const data = JSON.parse(content);
-        return data;
-    });
-}
-async function loadLocale(localesRoot) {
-    currentLocale = getLocale();
-    const fallbackFilePath = resolve(localesRoot, `${fallbackLocale}.json`);
-    const targetFilePath = resolve(localesRoot, `${currentLocale}.json`);
-    const messages = await loadLanguageFile(fallbackFilePath);
-    if (!messages)
-        throw Error('Fallback locale file not found.');
-    if (existsSync(targetFilePath))
-        merge(messages, await loadLanguageFile(targetFilePath));
-    return messages;
-}
-let localized;
-async function getLocalized() {
-    const path = fileURLToPath(new URL(localesPath, import.meta.url));
-    return localized ??= await loadLocale(path);
-}
-
-const { dim, red, cyan, green, yellow, bgRed, bgCyan, bgGreen, bgYellow, } = chalk;
-const dot = '•';
-const banner = `Mirta ${dot}`;
-const redBanner = red(banner);
-const cyanBanner = cyan(banner);
-const greenBanner = green(banner);
-const yellowBanner = yellow(banner);
-const infoPill = (message) => message ? bgCyan.black(` ${message} `) + (` ${cyan(dot)} `) : '';
-const successPill = (message) => message
-    ? bgGreen.black(` ${message} `) + ' '
-    : '';
-const warnPill = (message) => message ? bgYellow.black(` ${message} `) + (` ${yellow(dot)} `) : '';
-const errorPill = (message) => message
-    ? bgRed.white(` ${message} `) + ' '
-    : '';
-const formatMessage = (message) => message ? `${greenBanner} ${message}` : '';
-function useLogger(localized) {
-    function log(message) {
-        const formatted = formatMessage(message);
-        if (formatted)
-            console.log(formatted);
-    }
-    function step(message) {
-        if (message)
-            console.log(dim(message));
-    }
-    function info(message, title = localized.status.info) {
-        if (message)
-            console.log(`${cyanBanner} ${infoPill(title)}${cyan(message)}`);
-    }
-    function note(message, title = localized.status.note) {
-        if (message)
-            console.log(`${yellowBanner} ${warnPill(title)}${message}`);
-    }
-    function success(message, title = localized.status.success) {
-        if (message)
-            console.log(`${greenBanner} ${successPill(title)}${green(dot, message)}`);
-    }
-    function warn(message, title = localized.status.warn) {
-        if (message)
-            console.log(`${yellowBanner} ${warnPill(title)}${yellow(message)}`);
-    }
-    function error(message, title = localized.status.error) {
-        if (message)
-            console.log(`${redBanner} ${errorPill(title)}${red(dot, message)}`);
-    }
-    function cancel(message, title = localized.status.canceled) {
-        if (message)
-            console.log(`${redBanner} ${errorPill(title)}${red(dot, message)}`);
-    }
-    return {
-        log,
-        step,
-        info,
-        note,
-        success,
-        warn,
-        error,
-        cancel,
-    };
-}
-
-const messages = await getLocalized();
-const logger = useLogger(messages);
-class ShellError extends Error {
-    constructor(message) {
-        super(message);
-        // Убедимся, что экземпляр имеет правильный прототип
-        Object.setPrototypeOf(this, ShellError.prototype);
-        this.name = 'ShellError';
-        this.message = message;
-        Error.captureStackTrace(this, ShellError);
-    }
-}
-/**
- * @typedef ExecutionResult
- * @property {boolean} isDone
- * @property {number} code
- * @property {string} stderr
- * @property {string} stdout
- */
-async function execAsync(command, args, options) {
-    args ??= [];
-    return new Promise((resolve, reject) => {
-        const runner = spawn(command, args, {
-            stdio: [
-                'ignore', // stdin
-                'pipe', // stdout
-                'pipe', // stderr
-            ],
-            ...options,
-            shell: process.platform === 'win32',
-        });
-        const stdoutChunks = [];
-        const stderrChunks = [];
-        runner.stdout?.on('data', (chunk) => {
-            stdoutChunks.push(chunk);
-        });
-        runner.stderr?.on('data', (chunk) => {
-            stderrChunks.push(chunk);
-        });
-        runner.on('error', (error) => {
-            reject(error);
-        });
-        runner.on('exit', (code) => {
-            const isDone = code === 0;
-            const stdout = Buffer.concat(stdoutChunks).toString().trim();
-            const stderr = Buffer.concat(stderrChunks).toString().trim();
-            if (isDone) {
-                resolve({ isDone, code, stdout, stderr });
-            }
-            else {
-                reject(new ShellError(`Failed to execute command ${command} ${args.join(' ')}: ${stderr}`));
-            }
-        });
-    });
-}
-const runCommandAsync = async (command, args, options = {}) => await execAsync(command, args, { ...options });
-const dryRunCommandAsync = (command, args) => {
-    logger.info(`${command} ${args?.join(' ')}`, 'Dry');
-};
-runCommandAsync.ifNotDry = (isDryRun) => isDryRun ? dryRunCommandAsync : runCommandAsync;
-
-export { ShellError as S, getLocale as a, getLocalized as g, runCommandAsync as r, useLogger as u };