@lakutata/cli 2.17.0 → 3.0.0-beta.0

package/dist/esm/lib/I18n.js

@@ -0,0 +1,67 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeLocale } from 'lakutata/com/i18n';
+/**
+ * The messages of the validation (validation.json, the validation key of a file): not copied to a new language, which
+ * has its built-in ones
+ */
+const VALIDATION = 'validation';
+/**
+ * Write a file of the messages of a new language, made of a file of the default language (its validation messages left)
+ * @param source
+ * @param target
+ */
+async function copyMessages(source, target) {
+    const messages = JSON.parse(await readFile(source, 'utf8'));
+    delete messages[VALIDATION];
+    await writeFile(target, `${JSON.stringify(messages, null, 2)}\n`);
+}
+/**
+ * Copy the files of the messages of a directory of the default language, its validation messages left
+ * @param source
+ * @param target
+ * @param root whether it is the directory of the language (its validation.json and validation directory are left)
+ */
+async function copyDirectory(source, target, root) {
+    const files = [];
+    await mkdir(target, { recursive: true });
+    for (const entry of (await readdir(source, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (root && (entry.name === `${VALIDATION}.json` || entry.name === VALIDATION))
+            continue;
+        if (entry.isDirectory()) {
+            files.push(...await copyDirectory(path.join(source, entry.name), path.join(target, entry.name), false));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.json')) {
+            await copyMessages(path.join(source, entry.name), path.join(target, entry.name));
+            files.push(path.join(target, entry.name));
+        }
+    }
+    return files;
+}
+/**
+ * Add the messages of a language to a directory of the messages, made of the ones of the default language (a file or a
+ * directory, as the default language has): they are to be translated, lakutata i18n check telling the ones which are not
+ * @param directory
+ * @param locale
+ * @param defaultLocale
+ * @return the files written
+ */
+export async function addLocale(directory, locale, defaultLocale) {
+    const tag = normalizeLocale(locale);
+    if (!tag)
+        throw new Error(`"${locale}" is not the tag of a language (en, zh-CN, zh-Hant-TW)`);
+    const base = normalizeLocale(defaultLocale) ?? defaultLocale;
+    if (tag === base)
+        throw new Error(`${tag} is the default language`);
+    if (existsSync(path.join(directory, `${tag}.json`)) || existsSync(path.join(directory, tag)))
+        throw new Error(`The messages of ${tag} exist already in ${directory}`);
+    if (existsSync(path.join(directory, `${base}.json`))) {
+        const target = path.join(directory, `${tag}.json`);
+        await copyMessages(path.join(directory, `${base}.json`), target);
+        return [target];
+    }
+    if (existsSync(path.join(directory, base)))
+        return await copyDirectory(path.join(directory, base), path.join(directory, tag), true);
+    throw new Error(`There are no messages of the default language ${base} in ${directory} (${base}.json or ${base}/)`);
+}

package/dist/esm/lib/Language.js

@@ -0,0 +1,24 @@
+import { I18nMiddleware } from 'lakutata/com/i18n';
+/**
+ * The environment variable giving the language of the tool before the ones of the environment (LC_ALL, LANG)
+ */
+export const LANGUAGE_VARIABLE = 'LAKUTATA_LANG';
+/**
+ * The language of the commands of the tool: LAKUTATA_LANG, then the environment
+ */
+export class LanguageMiddleware extends I18nMiddleware {
+    constructor() {
+        super(...arguments);
+        this.environmentVariable = LANGUAGE_VARIABLE;
+    }
+}
+/**
+ * A text of the tool in the language of the user: its message (cli.<key>), its English text without it
+ * @param i18n
+ * @param key
+ * @param text
+ * @param params
+ */
+export function localize(i18n, key, text, params = {}) {
+    return i18n.has(`cli.${key}`) ? i18n.t(`cli.${key}`, params) : text.replace(/\{(\w+)\}/g, (all, name) => params[name] ?? all);
+}

package/dist/esm/lib/Migration.js

@@ -0,0 +1,94 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { camelCase } from 'lakutata/utils';
+import { LaunchEnvironment } from './Environment.js';
+import { spawnCommand } from './Processes.js';
+/**
+ * The files of a directory, none when it does not exist
+ * @param directory
+ */
+async function listFiles(directory) {
+    return existsSync(directory) ? await readdir(directory) : [];
+}
+/**
+ * Start the application of a package by its script, with the environment of a command of the migrations: the
+ * application does the command and exits
+ * @param application
+ * @param env
+ * @return the exit code of the application
+ */
+async function startApplication(application, env) {
+    const manifest = JSON.parse(await readFile(path.join(application.directory, 'package.json'), 'utf8'));
+    if (!manifest.scripts?.[application.script])
+        throw new Error(`The package ${application.directory} has no script "${application.script}" building and starting the application (--script)`);
+    //The variables of a previous command are not inherited
+    const base = Object.fromEntries(Object.entries(LaunchEnvironment).filter(([name]) => !name.toUpperCase().startsWith('MIGRATION_')));
+    return await new Promise((resolve, reject) => {
+        //The output of the application is the one of the command; the package managers are scripts on Windows
+        const child = spawnCommand('npm', ['run', application.script], {
+            cwd: application.directory,
+            stdio: 'inherit',
+            env: { ...base, ...env, ...(application.database ? { MIGRATION_DATABASE: application.database } : {}) }
+        });
+        child.once('error', reject);
+        child.once('close', (exitCode) => resolve(exitCode ?? 1));
+    });
+}
+/**
+ * Generate the migrations of an application: its script builds and starts it with MIGRATION_GENERATE, the application
+ * compares the entities of its Database components and providers with their databases, writes the migrations of the
+ * changes into the directory, and exits (as `cross-env MIGRATION_GENERATE=<dir> npm run <script>` in lakutata 2.x)
+ * @param options
+ */
+export async function generateMigrations(options) {
+    const directory = path.resolve(options.directory, options.dir);
+    const before = new Set(await listFiles(directory));
+    const code = await startApplication(options, { MIGRATION_GENERATE: options.dir });
+    const files = (await listFiles(directory)).filter((file) => !before.has(file)).sort();
+    return { code: code, files: files.map((file) => path.join(options.dir, file)) };
+}
+/**
+ * Run, revert or show the migrations of the databases of an application: its script builds and starts it with
+ * MIGRATION_RUN, MIGRATION_REVERT or MIGRATION_SHOW, the application connects its databases with their options (without
+ * synchronizing their schemas nor running their migrations), does the command, tells what it did, and exits
+ * @param options
+ * @return the exit code of the application
+ */
+export async function executeMigrations(options) {
+    return await startApplication(options, {
+        [`MIGRATION_${options.action.toUpperCase()}`]: '1',
+        ...(options.transaction ? { MIGRATION_TRANSACTION: options.transaction } : {}),
+        ...(options.fake ? { MIGRATION_FAKE: '1' } : {})
+    });
+}
+/**
+ * Create an empty migration, written by hand (the data of the tables, the changes the entities do not describe):
+ * `<timestamp>-<name>.ts`, its class `<Name><timestamp>` importing its types from @lakutata/orm when the package depends
+ * on it, otherwise from lakutata/orm (as the migrations generated)
+ * @param options
+ * @return the migration, relative to the package
+ */
+export async function createMigration(options) {
+    const timestamp = options.timestamp ?? Date.now();
+    const manifest = JSON.parse(await readFile(path.join(options.directory, 'package.json'), 'utf8'));
+    const module = manifest.dependencies?.['@lakutata/orm'] || manifest.devDependencies?.['@lakutata/orm'] ? '@lakutata/orm' : 'lakutata/orm';
+    const camel = camelCase(options.name);
+    const className = `${camel.charAt(0).toUpperCase()}${camel.slice(1)}${timestamp}`;
+    const file = path.join(options.dir, `${timestamp}-${options.name}.ts`);
+    await mkdir(path.resolve(options.directory, options.dir), { recursive: true });
+    await writeFile(path.resolve(options.directory, file), `import { MigrationInterface, QueryRunner } from "${module}";
+
+export class ${className} implements MigrationInterface {
+    name = '${className}'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+    }
+
+}
+`, { flag: 'wx' });
+    return file;
+}

package/dist/esm/lib/Output.js

@@ -0,0 +1,40 @@
+import { styleText } from 'node:util';
+/**
+ * A text in a style, when the output is a terminal
+ * @param style
+ * @param text
+ */
+export function styled(style, text) {
+    return process.stdout.isTTY && !process.env.NO_COLOR ? styleText(style, text) : text;
+}
+/**
+ * Print a step done
+ * @param message
+ */
+export function done(message) {
+    process.stdout.write(`${styled('green', '✔')} ${message}\n`);
+}
+/**
+ * Print a step in progress
+ * @param message
+ */
+export function step(message) {
+    process.stdout.write(`${styled('cyan', '›')} ${message}\n`);
+}
+/**
+ * Print a warning
+ * @param message
+ */
+export function warn(message) {
+    process.stderr.write(`${styled('yellow', '!')} ${message}\n`);
+}
+/**
+ * A table of names and values
+ * @param rows
+ * @param title
+ */
+export function table(rows, title) {
+    const width = Math.max(...rows.map(([name]) => name.length));
+    const lines = rows.map(([name, value]) => `  ${styled('blue', name.padEnd(width))}  ${value}`);
+    return `${title ? `${styled('bold', title)}\n` : ''}${lines.join('\n')}\n`;
+}

package/dist/esm/lib/Processes.js

@@ -0,0 +1,54 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { LaunchEnvironment } from './Environment.js';
+/**
+ * The package manager running the tool (npx, pnpm dlx, yarn dlx), npm by default
+ */
+export function detectPackageManager() {
+    const agent = process.env.npm_config_user_agent ?? '';
+    if (agent.startsWith('pnpm'))
+        return 'pnpm';
+    if (agent.startsWith('yarn'))
+        return 'yarn';
+    return 'npm';
+}
+/**
+ * An argument of a command run by cmd.exe (Windows): quoted as the programs read their arguments
+ * @param arg
+ */
+function quoted(arg) {
+    if (/^[\w\-.:/\\=@,+]+$/.test(arg))
+        return arg;
+    return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\+)$/, '$1$1')}"`;
+}
+/**
+ * Spawn a command: on Windows, the commands found in the PATH by their names (the package managers, the commands of npm:
+ * npm.cmd, bun.cmd) are scripts, run by cmd.exe with their arguments quoted; the executables given by their paths (the
+ * ones of spaces: C:\Program Files\nodejs\node.exe) are run as they are
+ * @param command
+ * @param args
+ * @param options
+ */
+export function spawnCommand(command, args, options) {
+    if (process.platform === 'win32' && !path.isAbsolute(command))
+        return spawn([command, ...args].map(quoted).join(' '), { ...options, shell: true });
+    return spawn(command, args, options);
+}
+/**
+ * Run a command, its output is given back
+ * @param command
+ * @param args
+ * @param cwd
+ * @return the exit code and the output
+ */
+export function runCommand(command, args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawnCommand(command, args, { cwd: cwd, env: LaunchEnvironment });
+        let output = '';
+        //Piped (the default stdio)
+        child.stdout.on('data', (chunk) => output += chunk.toString());
+        child.stderr.on('data', (chunk) => output += chunk.toString());
+        child.once('error', reject);
+        child.once('close', (code) => resolve({ code: code ?? 1, output: output }));
+    });
+}

package/dist/esm/lib/ProjectCreator.js

@@ -0,0 +1,191 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { existsSync } from 'node:fs';
+import { cp, readdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Component } from 'lakutata';
+import { Autoload, Inject, Singleton } from 'lakutata/decorator/di';
+import { templating } from 'lakutata/utils';
+import { TemplateCatalog } from './TemplateCatalog.js';
+import { runCommand } from './Processes.js';
+import { done, step, warn } from './Output.js';
+import { applyFeatureBlocks, applyFeatureFiles, projectPath } from './TemplateFeatures.js';
+import { frameworkVersion } from './Versions.js';
+/**
+ * The directories of a template which are not copied
+ */
+const SKIPPED = ['node_modules', '.git'];
+/**
+ * Whether a file is text: no NUL byte in its beginning
+ * @param content
+ */
+function isText(content) {
+    return !content.subarray(0, 8000).includes(0);
+}
+/**
+ * The files of a directory, relative to it
+ * @param directory
+ * @param base
+ */
+async function listFiles(directory, base = directory) {
+    const files = [];
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const target = path.join(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...await listFiles(target, base));
+        else if (entry.isFile())
+            files.push(path.relative(base, target));
+    }
+    return files;
+}
+/**
+ * Create the projects from the templates
+ */
+let ProjectCreator = class ProjectCreator extends Component {
+    /**
+     * Check the directory of a project
+     * @param directory
+     * @param init the project is created in an existing directory
+     */
+    async checkDirectory(directory, init) {
+        let exists = true;
+        try {
+            if (!(await stat(directory)).isDirectory())
+                throw new Error(`${directory} is not a directory`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            exists = false;
+        }
+        if (!exists) {
+            if (init)
+                throw new Error(`The directory ${directory} does not exist`);
+            return;
+        }
+        if (!init && (await readdir(directory)).length)
+            throw new Error(`The directory ${directory} is not empty (--init creates the project in an existing directory)`);
+    }
+    /**
+     * Copy the files of a template into the directory of the project
+     * @param template
+     * @param directory
+     * @return the paths of the files of the project, relative to its directory
+     */
+    async copy(template, directory) {
+        await cp(template.root, directory, {
+            recursive: true,
+            filter: (source) => !SKIPPED.includes(path.basename(source))
+        });
+        const files = [];
+        for (const file of await listFiles(directory)) {
+            //"_gitignore" becomes ".gitignore"
+            const renamed = projectPath(file);
+            if (renamed !== file)
+                await rename(path.join(directory, file), path.join(directory, renamed));
+            files.push(renamed);
+        }
+        return files;
+    }
+    /**
+     * Fill the information of the project into the files of the template ({$APP_NAME}…), the blocks of the features
+     * kept or removed
+     * @param directory
+     * @param files
+     * @param fields
+     * @param features the features enabled
+     */
+    async fill(directory, files, fields, features) {
+        for (const file of files) {
+            const target = path.join(directory, file);
+            const content = await readFile(target);
+            if (!isText(content))
+                continue;
+            const raw = content.toString('utf8');
+            const filled = templating(applyFeatureBlocks(raw, features, file), fields, { ignoreMissing: true });
+            if (filled !== raw)
+                await writeFile(target, filled);
+        }
+    }
+    /**
+     * Get the files of a template
+     * @param source
+     */
+    async prepare(source) {
+        step('Getting the template');
+        return await this.catalog.prepare(source);
+    }
+    /**
+     * Create a project from its template (prepared, its cleanup done by the caller)
+     * @param plan
+     * @param template
+     */
+    async create(plan, template) {
+        await this.checkDirectory(plan.directory, plan.init);
+        const files = await this.copy(template, plan.directory);
+        for (const feature of plan.features) {
+            if (!(feature in template.features))
+                throw new Error(`The template has no feature ${feature}`);
+            const directory = path.join(template.featuresDirectory, feature);
+            if (existsSync(directory))
+                files.push(...await applyFeatureFiles(directory, plan.directory));
+        }
+        done(`Template ${template.label} copied (${files.length} files${plan.features.length ? `, with ${plan.features.join(', ')}` : ''})`);
+        await this.fill(plan.directory, files, {
+            $APP_NAME: plan.name,
+            $APP_ID: plan.id,
+            $APP_DESC: plan.description,
+            $APP_AUTHOR: plan.author,
+            $APP_LICENSE: plan.license,
+            $LAKUTATA_VERSION: frameworkVersion()
+        }, new Set(plan.features));
+        done('Project information filled');
+        if (plan.packageManager !== 'none') {
+            step(`Installing the dependencies with ${plan.packageManager}`);
+            let result;
+            try {
+                result = await runCommand(plan.packageManager, ['install'], plan.directory);
+            }
+            catch (error) {
+                throw new Error(`${plan.packageManager} cannot be run: ${error.message}`, { cause: error });
+            }
+            if (result.code !== 0)
+                throw new Error(`${plan.packageManager} install failed:\n${result.output.trim().split('\n').slice(-20).join('\n')}`);
+            done('Dependencies installed');
+        }
+        if (plan.git) {
+            try {
+                const result = await runCommand('git', ['init'], plan.directory);
+                if (result.code === 0)
+                    done('Git repository initialized');
+                else
+                    warn(`git init failed: ${result.output.trim()}`);
+            }
+            catch {
+                warn('git is not installed, the git repository is not initialized');
+            }
+        }
+    }
+};
+__decorate([
+    Inject(TemplateCatalog),
+    __metadata("design:type", TemplateCatalog
+    /**
+     * Check the directory of a project
+     * @param directory
+     * @param init the project is created in an existing directory
+     */
+    )
+], ProjectCreator.prototype, "catalog", void 0);
+ProjectCreator = __decorate([
+    Autoload(),
+    Singleton()
+], ProjectCreator);
+export { ProjectCreator };

package/dist/esm/lib/Registry.js

@@ -0,0 +1,152 @@
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Settings } from './Settings.js';
+/**
+ * The URL of a package on the registry (the scope separator is encoded)
+ * @param name
+ */
+function packageURL(name) {
+    return `${Settings.registry}/${name.replace('/', '%2f')}`;
+}
+/**
+ * The parts of a version
+ * @param version
+ */
+function versionParts(version) {
+    const matched = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+.*)?$/.exec(version);
+    return matched ? { numbers: [Number(matched[1]), Number(matched[2]), Number(matched[3])], prerelease: matched[4] ? matched[4].split('.') : [] } : undefined;
+}
+/**
+ * Compare two versions as semver does: a prerelease is before its release, its identifiers are compared one by one
+ * (the numbers as numbers, before the words)
+ * @param a
+ * @param b
+ */
+export function compareVersions(a, b) {
+    const [x, y] = [versionParts(a), versionParts(b)];
+    const numbers = x.numbers[0] - y.numbers[0] || x.numbers[1] - y.numbers[1] || x.numbers[2] - y.numbers[2];
+    if (numbers)
+        return numbers;
+    if (!x.prerelease.length || !y.prerelease.length)
+        return y.prerelease.length - x.prerelease.length;
+    for (let index = 0; index < Math.max(x.prerelease.length, y.prerelease.length); index++) {
+        const [left, right] = [x.prerelease[index], y.prerelease[index]];
+        if (left === undefined || right === undefined)
+            return left === undefined ? -1 : 1;
+        if (left === right)
+            continue;
+        const [leftNumber, rightNumber] = [/^\d+$/.test(left), /^\d+$/.test(right)];
+        if (leftNumber && rightNumber)
+            return Number(left) - Number(right);
+        if (leftNumber !== rightNumber)
+            return leftNumber ? -1 : 1;
+        return left < right ? -1 : 1;
+    }
+    return 0;
+}
+/**
+ * The newest version of a major version (the prereleases only when the major version has no release)
+ * @param versions
+ * @param major any major version when undefined
+ */
+export function newestVersion(versions, major) {
+    const candidates = versions.filter((version) => {
+        const parts = versionParts(version);
+        return !!parts && (major === undefined || parts.numbers[0] === major);
+    });
+    const releases = candidates.filter((version) => !versionParts(version).prerelease.length);
+    return (releases.length ? releases : candidates).sort(compareVersions).at(-1);
+}
+/**
+ * The manifest of the newest version of a major version of a package (the prereleases when the major version has no
+ * release: the tags do not tell the major versions), undefined when it cannot be fetched
+ * @param name
+ * @param major
+ */
+export async function majorManifest(name, major) {
+    try {
+        const pkg = await resolvePackage(name, major);
+        if (!pkg)
+            return undefined;
+        const response = await fetch(`${packageURL(name)}/${encodeURIComponent(pkg.version)}`, { signal: AbortSignal.timeout(15000) });
+        return response.ok ? await response.json() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The directory of the cached archives of a package
+ * @param name
+ */
+function cacheDirectory(name) {
+    return path.join(Settings.cacheDirectory, 'packages', name);
+}
+/**
+ * The version of a package to download: the newest of the major version, or the given version
+ * @param name
+ * @param wanted a version ("1.2.3"), a major version (3) or the newest version (undefined)
+ * @return undefined when the package does not exist
+ */
+export async function resolvePackage(name, wanted) {
+    const response = await fetch(packageURL(name), { headers: { Accept: 'application/vnd.npm.install-v1+json' }, signal: AbortSignal.timeout(15000) });
+    if (response.status === 404)
+        return undefined;
+    if (!response.ok)
+        throw new Error(`The package ${name} cannot be fetched from ${Settings.registry}: ${response.status} ${response.statusText}`);
+    const metadata = await response.json();
+    const versions = Object.keys(metadata.versions ?? {});
+    const version = typeof wanted === 'string' ? (versions.includes(wanted) ? wanted : undefined) : newestVersion(versions, wanted);
+    if (!version)
+        throw new Error(`The package ${name} has no version ${typeof wanted === 'number' ? `${wanted}.x` : wanted} (${versions.join(', ') || 'no version'})`);
+    return { name: name, version: version, tarball: metadata.versions[version].dist.tarball };
+}
+/**
+ * The archive of a version of a package, downloaded once and cached
+ * @param pkg
+ */
+export async function downloadPackage(pkg) {
+    const file = path.join(cacheDirectory(pkg.name), `${pkg.version}.tgz`);
+    try {
+        return await readFile(file);
+    }
+    catch {
+        //Not cached
+    }
+    const response = await fetch(pkg.tarball, { signal: AbortSignal.timeout(60000) });
+    if (!response.ok)
+        throw new Error(`The package ${pkg.name}@${pkg.version} cannot be downloaded: ${response.status} ${response.statusText}`);
+    const archive = Buffer.from(await response.arrayBuffer());
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, archive);
+    return archive;
+}
+/**
+ * The newest cached archive of a package, when the registry cannot be reached
+ * @param name
+ * @param major
+ */
+export async function cachedPackage(name, major) {
+    let files;
+    try {
+        files = await readdir(cacheDirectory(name));
+    }
+    catch {
+        return undefined;
+    }
+    const version = newestVersion(files.filter((file) => file.endsWith('.tgz')).map((file) => file.slice(0, -4)), major);
+    return version ? { version: version, archive: await readFile(path.join(cacheDirectory(name), `${version}.tgz`)) } : undefined;
+}
+/**
+ * The package.json of the latest version of a package, undefined when it cannot be fetched
+ * @param name
+ */
+export async function latestManifest(name) {
+    try {
+        const response = await fetch(`${packageURL(name)}/latest`, { signal: AbortSignal.timeout(5000) });
+        return response.ok ? await response.json() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/esm/lib/Settings.js

@@ -0,0 +1,25 @@
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * The settings of the tool, from the environment variables (the npm registry and the GitHub mirror, the cache)
+ */
+export const Settings = {
+    /**
+     * The npm registry of the templates and of the versions: the one of npm (npm_config_registry) by default
+     */
+    get registry() {
+        return (process.env.LAKUTATA_NPM_REGISTRY ?? process.env.npm_config_registry ?? 'https://registry.npmjs.org').replace(/\/+$/, '');
+    },
+    /**
+     * The host of the archives of the GitHub repositories (the templates "github:owner/repo")
+     */
+    get githubDownload() {
+        return (process.env.LAKUTATA_GITHUB_DOWNLOAD ?? 'https://github.com').replace(/\/+$/, '');
+    },
+    /**
+     * The directory of the cache of the tool
+     */
+    get cacheDirectory() {
+        return process.env.LAKUTATA_CACHE_DIR ?? path.join(process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache'), 'lakutata');
+    }
+};