@lakutata/cli 2.17.0 → 3.0.0-beta.0

package/dist/esm/lib/native/Toml.js

@@ -0,0 +1,325 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { applyEdits, lineEndOf, lineIndent, NativeSyntaxError } from './TextEdits.js';
+/**
+ * The parser of TOML 1.0: the tables and the arrays of tables, the dotted and quoted keys, the basic and literal
+ * strings (multiline too), the arrays (their comments and trailing commas), the inline tables, the other values
+ * (numbers, booleans, dates) kept as their text
+ */
+class TomlParser {
+    constructor(file, text) {
+        this.file = file;
+        this.text = text;
+        this.offset = 0;
+    }
+    error(message, offset = this.offset) {
+        throw new NativeSyntaxError(this.file, this.text, offset, message);
+    }
+    /**
+     * Skip the spaces and tabs of a line
+     */
+    spaces() {
+        while (this.text[this.offset] === ' ' || this.text[this.offset] === '\t')
+            this.offset++;
+    }
+    /**
+     * Skip the whitespaces, the newlines and the comments (inside of the arrays)
+     */
+    blank() {
+        for (;;) {
+            this.spaces();
+            const char = this.text[this.offset];
+            if (char === '\n' || char === '\r')
+                this.offset++;
+            else if (char === '#')
+                this.comment();
+            else
+                return;
+        }
+    }
+    comment() {
+        while (this.offset < this.text.length && this.text[this.offset] !== '\n')
+            this.offset++;
+    }
+    /**
+     * The end of a line: spaces, a comment, a newline (or the end of the text)
+     */
+    lineEnd() {
+        this.spaces();
+        if (this.text[this.offset] === '#')
+            this.comment();
+        if (this.text[this.offset] === '\r')
+            this.offset++;
+        if (this.offset < this.text.length && this.text[this.offset] !== '\n')
+            this.error('expected the end of the line');
+        this.offset++;
+    }
+    parse() {
+        const tables = [{ path: [], array: false, header: -1, headerEnd: 0, entries: [] }];
+        for (;;) {
+            this.blank();
+            if (this.offset >= this.text.length)
+                return tables;
+            if (this.text[this.offset] === '[') {
+                const header = this.offset;
+                const array = this.text[this.offset + 1] === '[';
+                this.offset += array ? 2 : 1;
+                this.spaces();
+                const path = this.key();
+                this.spaces();
+                if (!this.text.startsWith(array ? ']]' : ']', this.offset))
+                    this.error(`expected "${array ? ']]' : ']'}"`);
+                this.offset += array ? 2 : 1;
+                const headerEnd = this.offset;
+                this.lineEnd();
+                tables.push({ path: path, array: array, header: header, headerEnd: headerEnd, entries: [] });
+            }
+            else {
+                tables.at(-1).entries.push(this.entry());
+                this.lineEnd();
+            }
+        }
+    }
+    /**
+     * A key: its parts, dotted (bare, basic or literal)
+     */
+    key() {
+        const parts = [];
+        for (;;) {
+            const char = this.text[this.offset];
+            if (char === '"' || char === '\'') {
+                parts.push(this.string().value);
+            }
+            else {
+                const bare = /^[A-Za-z0-9_-]+/.exec(this.text.slice(this.offset));
+                if (!bare)
+                    this.error('expected a key');
+                parts.push(bare[0]);
+                this.offset += bare[0].length;
+            }
+            this.spaces();
+            if (this.text[this.offset] !== '.')
+                return parts;
+            this.offset++;
+            this.spaces();
+        }
+    }
+    entry() {
+        const start = this.offset;
+        const key = this.key();
+        this.spaces();
+        if (this.text[this.offset] !== '=')
+            this.error('expected "="');
+        this.offset++;
+        this.spaces();
+        return { key: key, start: start, value: this.value() };
+    }
+    value() {
+        const char = this.text[this.offset];
+        if (char === '"' || char === '\'')
+            return this.string();
+        if (char === '[')
+            return this.array();
+        if (char === '{')
+            return this.inlineTable();
+        //The numbers, the booleans and the dates, their text
+        const other = /^[^\s,\]}#]+(?: [0-9:.+\-Z]+)?/.exec(this.text.slice(this.offset));
+        if (!other)
+            this.error(char === undefined ? 'unexpected end of the file' : `unexpected ${JSON.stringify(char)}`);
+        const start = this.offset;
+        this.offset += other[0].length;
+        return { kind: 'other', text: other[0], start: start, end: this.offset };
+    }
+    string() {
+        const start = this.offset;
+        const quote = this.text[this.offset];
+        const multiline = this.text.startsWith(quote.repeat(3), this.offset);
+        const delimiter = multiline ? quote.repeat(3) : quote;
+        this.offset += delimiter.length;
+        //The newline right after the opening of a multiline string is not part of it
+        if (multiline && this.text[this.offset] === '\n')
+            this.offset++;
+        else if (multiline && this.text.startsWith('\r\n', this.offset))
+            this.offset += 2;
+        let value = '';
+        for (;;) {
+            if (this.offset >= this.text.length)
+                this.error('unterminated string', start);
+            if (this.text.startsWith(delimiter, this.offset)) {
+                //Up to two quotes before the closing ones are the end of the content of a multiline string ('''a''''')
+                let extra = 0;
+                while (multiline && extra < 2 && this.text[this.offset + delimiter.length + extra] === quote)
+                    extra++;
+                value += quote.repeat(extra);
+                this.offset += delimiter.length + extra;
+                return { kind: 'string', value: value, start: start, end: this.offset };
+            }
+            const char = this.text[this.offset];
+            if (!multiline && char === '\n')
+                this.error('unterminated string', start);
+            if (char === '\\' && quote === '"') {
+                const next = this.text[this.offset + 1] ?? '';
+                if (multiline && /[ \t\r\n]/.test(next)) {
+                    //A line ending backslash: the whitespaces and newlines after it trimmed
+                    this.offset++;
+                    while (/[ \t\r\n]/.test(this.text[this.offset] ?? ''))
+                        this.offset++;
+                    continue;
+                }
+                const escapes = { 'b': '\b', 't': '\t', 'n': '\n', 'f': '\f', 'r': '\r', 'e': '\x1b', '"': '"', '\\': '\\' };
+                if (next in escapes) {
+                    value += escapes[next];
+                    this.offset += 2;
+                }
+                else if (next === 'u' || next === 'U' || next === 'x') {
+                    const length = next === 'u' ? 4 : next === 'U' ? 8 : 2;
+                    value += String.fromCodePoint(parseInt(this.text.slice(this.offset + 2, this.offset + 2 + length), 16));
+                    this.offset += 2 + length;
+                }
+                else {
+                    this.error(`invalid escape "\\${next}"`);
+                }
+                continue;
+            }
+            value += char;
+            this.offset++;
+        }
+    }
+    array() {
+        const start = this.offset;
+        this.offset++;
+        const items = [];
+        let trailingComma = false;
+        for (;;) {
+            this.blank();
+            if (this.text[this.offset] === ']')
+                break;
+            items.push(this.value());
+            trailingComma = false;
+            this.blank();
+            if (this.text[this.offset] === ',') {
+                this.offset++;
+                trailingComma = true;
+            }
+            else if (this.text[this.offset] !== ']') {
+                this.error('expected "," or "]"');
+            }
+        }
+        const close = this.offset;
+        this.offset++;
+        return { kind: 'array', items: items, start: start, end: this.offset, close: close, trailingComma: trailingComma };
+    }
+    inlineTable() {
+        const start = this.offset;
+        this.offset++;
+        const entries = [];
+        for (;;) {
+            this.blank();
+            if (this.text[this.offset] === '}')
+                break;
+            entries.push(this.entry());
+            this.blank();
+            if (this.text[this.offset] === ',')
+                this.offset++;
+            else if (this.text[this.offset] !== '}')
+                this.error('expected "," or "}"');
+        }
+        this.offset++;
+        return { kind: 'inline-table', entries: entries, start: start, end: this.offset };
+    }
+}
+/**
+ * A key of TOML: bare when it can be, otherwise literal ('…'), or basic ("…") when it has a quote
+ * @param key
+ */
+export function tomlKey(key) {
+    if (/^[A-Za-z0-9_-]+$/.test(key))
+        return key;
+    return key.includes('\'') ? JSON.stringify(key) : `'${key}'`;
+}
+/**
+ * A string of TOML (basic)
+ * @param value
+ */
+export function tomlStringText(value) {
+    return JSON.stringify(value);
+}
+/**
+ * A document of TOML (.cargo/config.toml), parsed with the places of its tables and values: it is changed by edits of
+ * its text, its comments and its layout kept
+ */
+export class TomlDocument {
+    constructor(file, text) {
+        this.file = file;
+        this.text = text;
+        this.edits = [];
+        this.tables = new TomlParser(file, text).parse();
+    }
+    /**
+     * The document of a file (empty when it does not exist)
+     * @param file
+     */
+    static async read(file) {
+        return new TomlDocument(file, existsSync(file) ? await readFile(file, 'utf8') : '');
+    }
+    get changes() {
+        return this.edits;
+    }
+    applied() {
+        return new TomlDocument(this.file, applyEdits(this.text, this.edits));
+    }
+    /**
+     * The table of a path (not an array of tables)
+     * @param path
+     */
+    table(path) {
+        return this.tables.find((candidate) => !candidate.array && candidate.path.length === path.length && candidate.path.every((part, index) => part === path[index]));
+    }
+    /**
+     * The string of a key of a table
+     * @param path the path of the table
+     * @param key
+     */
+    string(path, key) {
+        const value = this.table(path)?.entries.find((entry) => entry.key.length === 1 && entry.key[0] === key)?.value;
+        if (value && value.kind !== 'string')
+            throw new NativeSyntaxError(this.file, this.text, value.start, `"${key}" is not a string`);
+        return value?.value;
+    }
+    /**
+     * Add values to a list in a string of a table, its items separated by a separator (the table and the key created
+     * when missing); the values already in it are skipped
+     * @param path the path of the table
+     * @param key
+     * @param values
+     * @param separator
+     * @return whether the document is changed
+     */
+    addToStringList(path, key, values, separator) {
+        const current = this.string(path, key);
+        const items = current === undefined ? [] : current.split(separator).filter((item) => item.trim() !== '');
+        const missing = values.filter((value, index) => !items.includes(value) && values.indexOf(value) === index);
+        if (!missing.length)
+            return false;
+        const rendered = tomlStringText([...items, ...missing].join(separator));
+        const table = this.table(path);
+        if (!table) {
+            const blank = !this.text.length ? '' : this.text.endsWith('\n\n') ? '' : this.text.endsWith('\n') ? '\n' : '\n\n';
+            this.edits.push({ offset: this.text.length, remove: 0, insert: `${blank}[${path.map(tomlKey).join('.')}]\n${tomlKey(key)} = ${rendered}\n` });
+            return true;
+        }
+        const entry = table.entries.find((candidate) => candidate.key.length === 1 && candidate.key[0] === key);
+        if (entry) {
+            this.edits.push({ offset: entry.value.start, remove: entry.value.end - entry.value.start, insert: rendered });
+            return true;
+        }
+        //After the last entry of the table, or its header
+        const last = table.entries.at(-1);
+        const after = lineEndOf(this.text, last ? last.value.end : table.headerEnd);
+        const indent = last ? lineIndent(this.text, last.start) : '';
+        this.edits.push(after < this.text.length
+            ? { offset: after, remove: 0, insert: `\n${indent}${tomlKey(key)} = ${rendered}` }
+            : { offset: after, remove: 0, insert: `${this.text.endsWith('\n') ? '' : '\n'}${indent}${tomlKey(key)} = ${rendered}\n` });
+        return true;
+    }
+}

package/dist/esm/lib/workspace/Run.js

@@ -0,0 +1,111 @@
+import os from 'node:os';
+import { LaunchEnvironment } from '../Environment.js';
+import { spawnCommand } from '../Processes.js';
+import { styled, warn } from '../Output.js';
+import { matchName } from './Workspace.js';
+const COLORS = ['cyan', 'magenta', 'yellow', 'green', 'blue', 'red'];
+/**
+ * Run a script of a package, its output prefixed with the name of the package
+ * @param pkg
+ * @param script
+ * @param args
+ * @param prefix
+ */
+function runPackageScript(pkg, script, args, prefix) {
+    return new Promise((resolve) => {
+        const child = spawnCommand('npm', ['run', script, ...(args.length ? ['--', ...args] : [])], { cwd: pkg.directory, env: LaunchEnvironment });
+        const forward = (stream, target) => {
+            let pending = '';
+            stream.on('data', (chunk) => {
+                const lines = (pending + chunk.toString()).split('\n');
+                pending = lines.pop();
+                for (const line of lines)
+                    target.write(`${prefix} ${line}\n`);
+            });
+            stream.on('end', () => {
+                if (pending)
+                    target.write(`${prefix} ${pending}\n`);
+            });
+        };
+        //Piped (the default stdio)
+        forward(child.stdout, process.stdout);
+        forward(child.stderr, process.stderr);
+        child.once('error', (error) => {
+            process.stderr.write(`${prefix} ${error.message}\n`);
+            resolve(1);
+        });
+        child.once('close', (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Run a script in the packages of a workspace having it: a package runs once the packages it depends on ran,
+ * the packages independent of each other run at the same time
+ * @param workspace
+ * @param script
+ * @param options
+ */
+export async function runScript(workspace, script, options = {}) {
+    const inScope = (pkg) => !options.scope?.length || options.scope.some((pattern) => matchName(pkg.name, pattern));
+    const selected = workspace.packages.filter((pkg) => inScope(pkg) && !!pkg.scripts[script]);
+    const skipped = workspace.packages.filter((pkg) => inScope(pkg) && !pkg.scripts[script]).map((pkg) => pkg.name);
+    const selectedNames = new Set(selected.map((pkg) => pkg.name));
+    if (!options.parallel)
+        for (const cycle of workspace.cycles())
+            warn(`The packages depend on each other: ${cycle.join(' → ')}, they run in the order of their names`);
+    //The selected packages each one waits for (through the packages without the script too); the cycles are broken by name
+    const waitsFor = new Map(selected.map((pkg) => {
+        if (options.parallel)
+            return [pkg.name, new Set()];
+        const dependencies = new Set([...workspace.transitiveDependencies(pkg)].filter((name) => selectedNames.has(name)));
+        for (const name of dependencies)
+            if (workspace.transitiveDependencies(workspace.get(name)).has(pkg.name) && name > pkg.name)
+                dependencies.delete(name);
+        return [pkg.name, dependencies];
+    }));
+    const concurrency = options.parallel ? Math.max(1, selected.length) : Math.max(1, options.concurrency ?? os.availableParallelism());
+    const width = Math.max(0, ...selected.map((pkg) => pkg.name.length));
+    const done = new Set();
+    //The packages depending on a failed package, not run
+    const blocked = new Set();
+    const failed = [];
+    const ran = [];
+    const running = new Map();
+    let stopped = false;
+    while (true) {
+        if (!stopped) {
+            for (const pkg of selected) {
+                if (running.size >= concurrency)
+                    break;
+                if (done.has(pkg.name) || blocked.has(pkg.name) || running.has(pkg.name) || failed.includes(pkg.name))
+                    continue;
+                if (![...waitsFor.get(pkg.name)].every((name) => done.has(name)))
+                    continue;
+                const prefix = styled(COLORS[selected.indexOf(pkg) % COLORS.length], `${pkg.name.padEnd(width)} │`);
+                running.set(pkg.name, runPackageScript(pkg, script, options.args ?? [], prefix).then((code) => {
+                    running.delete(pkg.name);
+                    if (code === 0) {
+                        done.add(pkg.name);
+                        ran.push(pkg.name);
+                    }
+                    else {
+                        failed.push(pkg.name);
+                        if (options.bail !== false)
+                            stopped = true;
+                        //The packages depending on a failed package do not run
+                        else
+                            for (const other of selected)
+                                if (waitsFor.get(other.name).has(pkg.name))
+                                    blocked.add(other.name);
+                    }
+                }));
+            }
+        }
+        if (!running.size)
+            break;
+        await Promise.race(running.values());
+    }
+    const notRun = selected.map((pkg) => pkg.name).filter((name) => !ran.includes(name) && !failed.includes(name));
+    if (failed.length)
+        throw new Error(`${script} failed in ${failed.join(', ')}${notRun.length ? `, not run in ${notRun.join(', ')}` : ''}`);
+    return { ran: ran, skipped: skipped, failed: failed };
+}

package/dist/esm/lib/workspace/Version.js

@@ -0,0 +1,144 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { runCommand } from '../Processes.js';
+import { warn } from '../Output.js';
+import { DEPENDENCY_FIELDS } from './Workspace.js';
+const VERSION = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+/**
+ * The next version
+ * @param current
+ * @param bump a bump, or a version
+ * @param preid the identifier of the prereleases ("beta"), none by default
+ */
+export function nextVersion(current, bump, preid) {
+    if (VERSION.test(bump))
+        return bump;
+    const matched = VERSION.exec(current);
+    if (!matched)
+        throw new Error(`The current version "${current}" is not a version`);
+    const [major, minor, patch] = [Number(matched[1]), Number(matched[2]), Number(matched[3])];
+    const prerelease = matched[4];
+    const pre = () => preid ? `${preid}.0` : '0';
+    switch (bump) {
+        case 'major':
+            return prerelease && minor === 0 && patch === 0 ? `${major}.0.0` : `${major + 1}.0.0`;
+        case 'minor':
+            return prerelease && patch === 0 ? `${major}.${minor}.0` : `${major}.${minor + 1}.0`;
+        case 'patch':
+            return prerelease ? `${major}.${minor}.${patch}` : `${major}.${minor}.${patch + 1}`;
+        case 'premajor':
+            return `${major + 1}.0.0-${pre()}`;
+        case 'preminor':
+            return `${major}.${minor + 1}.0-${pre()}`;
+        case 'prepatch':
+            return `${major}.${minor}.${patch + 1}-${pre()}`;
+        case 'prerelease': {
+            if (!prerelease)
+                return `${major}.${minor}.${patch + 1}-${pre()}`;
+            const parts = prerelease.split('.');
+            const last = Number(parts.at(-1));
+            //1.0.0-beta.1 → 1.0.0-beta.2; another identifier starts again
+            if (preid && parts[0] !== preid)
+                return `${major}.${minor}.${patch}-${preid}.0`;
+            if (Number.isInteger(last))
+                parts[parts.length - 1] = String(last + 1);
+            else
+                parts.push('0');
+            return `${major}.${minor}.${patch}-${parts.join('.')}`;
+        }
+        default:
+            throw new Error(`Invalid bump "${bump}": major, minor, patch, premajor, preminor, prepatch, prerelease or a version`);
+    }
+}
+/**
+ * The range of a dependency on a package of the workspace, for its new version: its prefix is kept ("^0.0.3" → "^0.0.4"),
+ * the ranges which are not a version ("*", "workspace:*", "file:…") are kept
+ * @param range
+ * @param version
+ */
+export function updateRange(range, version) {
+    const matched = /^(workspace:)?(\^|~|>=|<=|>|<|=)?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)$/.exec(range);
+    return matched ? `${matched[1] ?? ''}${matched[2] ?? ''}${version}` : range;
+}
+/**
+ * The versions a bump gives
+ * @param workspace
+ * @param bump
+ * @param preid
+ */
+export function planVersion(workspace, bump, preid) {
+    const from = workspace.version ?? '0.0.0';
+    return {
+        from: from,
+        to: nextVersion(from, bump, preid),
+        packages: workspace.packages.map((pkg) => ({ name: pkg.name, from: pkg.version }))
+    };
+}
+/**
+ * Give the packages of the workspace a version (a fixed version: the same for all), update the dependencies between them and the lock file
+ * @param workspace
+ * @param plan
+ * @param options
+ */
+export async function applyVersion(workspace, plan, options = {}) {
+    const names = new Set(workspace.packages.map((pkg) => pkg.name));
+    const changed = [];
+    for (const pkg of workspace.packages) {
+        const data = pkg.manifest.data;
+        data.version = plan.to;
+        for (const field of DEPENDENCY_FIELDS) {
+            for (const [name, range] of Object.entries(data[field] ?? {})) {
+                if (names.has(name))
+                    data[field][name] = updateRange(range, plan.to);
+            }
+        }
+        changed.push(pkg.manifest);
+    }
+    //The version of the workspace is kept by lerna.json when it has one, by the root package.json otherwise
+    if (workspace.lerna) {
+        workspace.lerna.data.version = plan.to;
+        changed.push(workspace.lerna);
+    }
+    else {
+        workspace.manifest.data.version = plan.to;
+        changed.push(workspace.manifest);
+    }
+    //The root package.json may depend on the packages too
+    for (const field of DEPENDENCY_FIELDS) {
+        for (const [name, range] of Object.entries(workspace.manifest.data[field] ?? {})) {
+            if (names.has(name))
+                workspace.manifest.data[field][name] = updateRange(range, plan.to);
+        }
+    }
+    if (!changed.includes(workspace.manifest))
+        changed.push(workspace.manifest);
+    for (const file of changed)
+        await file.write();
+    const files = changed.map((file) => file.file);
+    //The lock file follows (npm ci and the frozen installs fail otherwise)
+    const lock = [
+        { file: 'package-lock.json', command: 'npm', args: ['install', '--package-lock-only', '--ignore-scripts', '--no-audit', '--no-fund'] },
+        { file: 'pnpm-lock.yaml', command: 'pnpm', args: ['install', '--lockfile-only', '--ignore-scripts'] }
+    ].find((candidate) => existsSync(path.join(workspace.root, candidate.file)));
+    if (lock) {
+        const result = await runCommand(lock.command, lock.args, workspace.root).catch((error) => ({ code: 1, output: error.message }));
+        if (result.code === 0)
+            files.push(path.join(workspace.root, lock.file));
+        else
+            warn(`The lock file ${lock.file} is not updated (run ${lock.command} install): ${result.output.trim().split('\n').slice(-3).join(' ')}`);
+    }
+    else if (existsSync(path.join(workspace.root, 'yarn.lock'))) {
+        warn('yarn.lock is not updated: run yarn install');
+    }
+    if (options.git) {
+        const git = async (args) => {
+            const result = await runCommand('git', args, workspace.root);
+            if (result.code !== 0)
+                throw new Error(`git ${args[0]} failed: ${result.output.trim()}`);
+        };
+        await git(['add', ...files]);
+        await git(['commit', '-m', `v${plan.to}`]);
+        await git(['tag', `v${plan.to}`]);
+    }
+    return files;
+}