@lakutata/cli 2.17.0 → 3.0.0-beta.0

package/dist/esm/lib/AddPackage.js

@@ -0,0 +1,487 @@
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { Workspace } from './workspace/Workspace.js';
+/**
+ * The versions of the dependencies of the native addons
+ */
+const NATIVE_VERSIONS = {
+    'node-addon-api': '^8.9.2',
+    'node-gyp-build': '^4.8.4',
+    'node-gyp': '^12.4.0',
+    'cmake-js': '^8.0.0',
+    '@napi-rs/cli': '^3.10.6'
+};
+/**
+ * The compiler options of the packages (as the ones of the templates), their declarations emitted for the packages
+ * depending on them
+ * @param outDir
+ */
+function tsConfig(outDir) {
+    return `${JSON.stringify({
+        compilerOptions: {
+            target: 'ES2022',
+            lib: ['ES2022'],
+            module: 'NodeNext',
+            moduleResolution: 'NodeNext',
+            rootDir: 'src',
+            outDir: outDir,
+            declaration: true,
+            types: ['node'],
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true
+        },
+        include: ['src']
+    }, null, 2)}\n`;
+}
+/**
+ * The files of a TypeScript package
+ * @param name
+ * @param version
+ */
+function libraryFiles(name, version) {
+    return {
+        'package.json': `${JSON.stringify({
+            name: name,
+            version: version,
+            private: true,
+            type: 'module',
+            main: 'build/index.js',
+            types: 'build/index.d.ts',
+            exports: { '.': { types: './build/index.d.ts', default: './build/index.js' } },
+            files: ['build', '!build/tests'],
+            scripts: {
+                clean: 'lakutata clean',
+                build: 'tsc',
+                rebuild: 'npm run clean && npm run build',
+                test: 'node --test "build/tests/**/*.spec.js"'
+            }
+        }, null, 2)}\n`,
+        'tsconfig.json': tsConfig('build'),
+        'src/index.ts': `/**
+ * Greet someone
+ * @param name
+ */
+export function Greet(name: string): string {
+    return \`Hello, \${name}\`
+}
+`,
+        'src/tests/index.spec.ts': `import {describe, it} from 'node:test'
+import assert from 'node:assert'
+import {Greet} from '../index.js'
+
+describe('${name}', (): void => {
+    it('greets', (): void => {
+        assert.strictEqual(Greet('lakutata'), 'Hello, lakutata')
+    })
+})
+`,
+        'README.md': `# ${name}\n\n\`\`\`bash\nnpm run rebuild   # compile\nnpm test          # run the tests\n\`\`\`\n`
+    };
+}
+/**
+ * The build files of an addon built by node-gyp: binding.gyp, its options commented
+ * @param target
+ */
+function gypFiles(target) {
+    return {
+        'binding.gyp': `# The build of the addon by node-gyp (gyp: a Python literal, its comments start with #)
+{
+  'targets': [
+    {
+      'target_name': '${target}',
+      'sources': ['cpp/binding.cc'],
+      # The C++ exceptions of node-addon-api (thrown in JavaScript as errors) on every platform
+      'dependencies': ["<!(node -p \\"require('node-addon-api').targets\\"):node_addon_api_except"],
+      'defines': ['NAPI_VERSION=8'],
+      'include_dirs': [
+        # The headers of the addon and of its libraries: 'deps/include'
+      ],
+      'libraries': [
+        # The libraries of the addon (lakutata native link writes them, or by hand):
+        # A library of the system: '-lpcap' (Linux, macOS), 'ws2_32.lib' (Windows, in its condition below)
+        # A static library of the package: '<(module_root_dir)/deps/lib/libfoo.a'
+        # A library found by pkg-config: '<!@(pkg-config --libs libpcap)' (its headers in include_dirs:
+        #   '<!@(pkg-config --cflags-only-I libpcap | sed s/-I//g)')
+        # A dynamic library shipped with the addon (deps/lib/libfoo.so, .dylib): '-L<(module_root_dir)/deps/lib', '-lfoo',
+        #   copied next to the addon (copies below) and found there at run time (the rpath of the conditions below)
+      ],
+      # 'copies': [{'destination': '<(PRODUCT_DIR)', 'files': ['<(module_root_dir)/deps/lib/libfoo.so']}],
+      'conditions': [
+        ['OS=="mac"', {
+          'xcode_settings': {
+            'MACOSX_DEPLOYMENT_TARGET': '11.0',
+            # One addon for the Macs with Intel and with Apple silicon
+            'OTHER_CFLAGS': ['-arch x86_64', '-arch arm64'],
+            'OTHER_LDFLAGS': [
+              '-arch x86_64', '-arch arm64',
+              # The dynamic libraries shipped with the addon, found next to it: '-Wl,-rpath,@loader_path'
+              # A framework of the system: '-framework CoreFoundation'
+            ],
+            # The standard of C++: 'CLANG_CXX_LANGUAGE_STANDARD': 'c++20'
+          }
+        }],
+        ['OS=="linux"', {
+          'ldflags': [
+            # The dynamic libraries shipped with the addon, found next to it: "-Wl,-rpath,'$$ORIGIN'"
+          ],
+          # The standard of C++: 'cflags_cc': ['-std=c++20']
+        }],
+        ['OS=="win"', {
+          'msvs_settings': {
+            'VCCLCompilerTool': {
+              'AdditionalOptions': ['/utf-8']
+              # The standard of C++: '/std:c++20'
+            }
+          },
+          'libraries': [
+            # A library of the system: 'ws2_32.lib', 'iphlpapi.lib'
+            # A static library of the package: '<(module_root_dir)/deps/lib/foo.lib'
+            # A DLL shipped with the addon (deps/lib/foo.dll): its import library '<(module_root_dir)/deps/lib/foo.lib',
+            #   the DLL copied next to the addon (copies below), where Windows finds it at run time
+          ],
+          # 'copies': [{'destination': '<(PRODUCT_DIR)', 'files': ['<(module_root_dir)/deps/lib/foo.dll']}]
+        }]
+      ]
+    }
+  ]
+}
+`,
+        'cpp/binding.cc': cppBinding(target)
+    };
+}
+/**
+ * The build files of an addon built by cmake-js: CMakeLists.txt, its options commented
+ * @param target
+ */
+function cMakeFiles(target) {
+    return {
+        'CMakeLists.txt': `# The build of the addon by cmake-js (npm run build:native)
+cmake_minimum_required(VERSION 3.15)
+cmake_policy(SET CMP0091 NEW)
+cmake_policy(SET CMP0042 NEW)
+
+# One addon for the Macs with Intel and with Apple silicon (forced: cmake-js gives the architecture of the machine)
+set(CMAKE_OSX_ARCHITECTURES "arm64;x86_64" CACHE STRING "The architectures of macOS" FORCE)
+set(CMAKE_OSX_DEPLOYMENT_TARGET "11.0")
+
+project(${target})
+
+# The standard of C++: the headers of Node.js (and node-addon-api) need C++20, as node-gyp gives it
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(\${PROJECT_NAME} SHARED cpp/binding.cc \${CMAKE_JS_SRC})
+set_target_properties(\${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
+
+# The headers of Node.js and of node-addon-api; the C++ exceptions thrown in JavaScript as errors
+execute_process(COMMAND node -p "require('node-addon-api').include" WORKING_DIRECTORY \${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE NODE_ADDON_API_DIR)
+string(REGEX REPLACE "[\\r\\n\\"]" "" NODE_ADDON_API_DIR \${NODE_ADDON_API_DIR})
+target_include_directories(\${PROJECT_NAME} PRIVATE \${CMAKE_JS_INC} \${NODE_ADDON_API_DIR})
+target_compile_definitions(\${PROJECT_NAME} PRIVATE NAPI_VERSION=8 NAPI_CPP_EXCEPTIONS)
+if(MSVC)
+    target_compile_options(\${PROJECT_NAME} PRIVATE /utf-8 /EHsc)
+endif()
+target_link_libraries(\${PROJECT_NAME} \${CMAKE_JS_LIB})
+
+# The libraries of the addon (lakutata native link writes them, or by hand):
+# - a library of the system: target_link_libraries(\${PROJECT_NAME} pcap) (Windows: ws2_32)
+# - a library found by pkg-config:
+#     find_package(PkgConfig REQUIRED)
+#     pkg_check_modules(PCAP REQUIRED libpcap)
+#     target_include_directories(\${PROJECT_NAME} PRIVATE \${PCAP_INCLUDE_DIRS})
+#     target_link_libraries(\${PROJECT_NAME} \${PCAP_LIBRARIES})
+# - a package of CMake: find_package(ZLIB REQUIRED) then target_link_libraries(\${PROJECT_NAME} ZLIB::ZLIB)
+# - a static library of the package: target_link_libraries(\${PROJECT_NAME} \${CMAKE_SOURCE_DIR}/deps/lib/libfoo.a)
+#     (Windows: deps/lib/foo.lib)
+# - a library built from its sources (its own CMakeLists.txt): add_subdirectory(deps/foo) then
+#     target_link_libraries(\${PROJECT_NAME} foo)
+# - a dynamic library shipped with the addon (deps/lib), copied next to it and found there at run time:
+#     target_link_libraries(\${PROJECT_NAME} \${CMAKE_SOURCE_DIR}/deps/lib/libfoo.so)
+#     set_target_properties(\${PROJECT_NAME} PROPERTIES BUILD_RPATH "$<IF:$<PLATFORM_ID:Darwin>,@loader_path,$ORIGIN>")
+#     add_custom_command(TARGET \${PROJECT_NAME} POST_BUILD COMMAND \${CMAKE_COMMAND} -E copy \${CMAKE_SOURCE_DIR}/deps/lib/libfoo.so $<TARGET_FILE_DIR:\${PROJECT_NAME}>)
+#   (Windows: the DLL linked by its import library, deps/lib/foo.lib, and copied next to the addon, where Windows finds
+#   it; no rpath)
+
+# The import library of Node.js on Windows
+if(MSVC AND CMAKE_JS_NODELIB_DEF AND CMAKE_JS_NODELIB_TARGET)
+    execute_process(COMMAND \${CMAKE_AR} /def:\${CMAKE_JS_NODELIB_DEF} /out:\${CMAKE_JS_NODELIB_TARGET} \${CMAKE_STATIC_LINKER_FLAGS})
+endif()
+`,
+        'cpp/binding.cc': cppBinding(target)
+    };
+}
+/**
+ * The build files of an addon of Rust built by napi-rs: Cargo.toml, build.rs and rust/lib.rs
+ * @param target
+ * @param version
+ */
+function rustFiles(target, version) {
+    return {
+        'Cargo.toml': `[package]
+name = "${target}"
+version = "${version.replace(/[-+].*$/, '')}"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+path = "rust/lib.rs"
+
+[dependencies]
+# Node-API: the same addon runs in Node.js and Electron
+napi = { version = "3", default-features = false, features = ["napi8"] }
+napi-derive = "3"
+# The crates of the addon: their native libraries are built and linked by cargo (their build.rs)
+
+[build-dependencies]
+napi-build = "2"
+
+[profile.release]
+lto = true
+strip = "symbols"
+`,
+        'build.rs': `use std::env;
+use std::path::Path;
+
+fn main() {
+    napi_build::setup();
+    // The native libraries of the addon (beside its crates), given by lakutata native link in .cargo/config.toml: the
+    // directives of cargo of every platform (LAKUTATA_NATIVE) and of one (LAKUTATA_NATIVE_MACOS, LAKUTATA_NATIVE_LINUX,
+    // LAKUTATA_NATIVE_WINDOWS, LAKUTATA_NATIVE_UNIX), separated by ";", their directories relative to the package
+    let root = env::var("CARGO_MANIFEST_DIR").unwrap();
+    let mut keys = vec![String::from("LAKUTATA_NATIVE")];
+    for cfg in ["CARGO_CFG_TARGET_OS", "CARGO_CFG_TARGET_FAMILY"] {
+        for value in env::var(cfg).unwrap_or_default().split(',').filter(|value| !value.is_empty()) {
+            let key = format!("LAKUTATA_NATIVE_{}", value.to_uppercase());
+            if !keys.contains(&key) {
+                keys.push(key);
+            }
+        }
+    }
+    for key in keys {
+        println!("cargo:rerun-if-env-changed={}", key);
+        for directive in env::var(&key).unwrap_or_default().split(';').map(str::trim).filter(|directive| !directive.is_empty()) {
+            match directive.strip_prefix("rustc-link-search=") {
+                Some(search) => {
+                    let (kind, directory) = search.split_once('=').unwrap_or(("all", search));
+                    println!("cargo:rustc-link-search={}={}", kind, Path::new(&root).join(directory).display());
+                }
+                None => println!("cargo:{}", directive),
+            }
+        }
+    }
+}
+`,
+        'rust/lib.rs': `use napi_derive::napi;
+
+/// Greet someone: greet(name)
+#[napi]
+pub fn greet(name: String) -> String {
+    format!("Hello, {} (native)", name)
+}
+`
+    };
+}
+/**
+ * The C++ of an addon (node-addon-api)
+ * @param target
+ */
+function cppBinding(target) {
+    return `#include <napi.h>
+
+/**
+ * Greet someone: greet(name)
+ */
+static Napi::Value Greet(const Napi::CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    if (info.Length() < 1 || !info[0].IsString()) {
+        throw Napi::TypeError::New(env, "The name must be a string");
+    }
+    return Napi::String::New(env, "Hello, " + info[0].As<Napi::String>().Utf8Value() + " (native)");
+}
+
+static Napi::Object Init(Napi::Env env, Napi::Object exports) {
+    exports.Set("greet", Napi::Function::New(env, Greet));
+    return exports;
+}
+
+NODE_API_MODULE(${target}, Init)
+`;
+}
+/**
+ * How the libraries and the options of the build are given, by build system
+ */
+const NATIVE_GUIDES = {
+    gyp: `C++ with [node-addon-api](https://github.com/nodejs/node-addon-api), built by node-gyp from \`binding.gyp\`.
+
+The libraries and the options of the build are given in \`binding.gyp\`, whose comments show them: the libraries of
+the system (\`-lpcap\`, \`ws2_32.lib\`, the frameworks of macOS), the ones found by pkg-config, the static libraries
+of the package, the dynamic libraries shipped with the addon (copied next to it, found there at run time by its rpath:
+\`$ORIGIN\` on Linux, \`@loader_path\` on macOS), the standard of C++, the options of each platform (\`conditions\`).`,
+    cmake: `C++ with [node-addon-api](https://github.com/nodejs/node-addon-api), built by [cmake-js](https://github.com/cmake-js/cmake-js)
+from \`CMakeLists.txt\`.
+
+The libraries and the options of the build are given in \`CMakeLists.txt\`, whose comments show them: the libraries of
+the system, the ones found by pkg-config or by \`find_package\`, the static libraries of the package, the libraries built
+from their sources (\`add_subdirectory\`), the dynamic libraries shipped with the addon (copied next to it, found there
+at run time by its rpath). The headers of Node.js need C++20 (\`CMAKE_CXX_STANDARD\`).`,
+    rust: `Rust with [napi-rs](https://napi.rs), built by cargo (\`Cargo.toml\`, \`build.rs\`, \`rust/lib.rs\`).
+
+The libraries of the addon are crates (\`Cargo.toml\`), their native libraries built and linked by cargo; the other
+native libraries are linked by \`build.rs\`, given by \`lakutata native link\`. The addon is built for the platform and the
+architecture of the machine (\`rustup target add\` builds the other ones).`
+};
+/**
+ * The files of a native addon: built into build/Release (gyp, cmake-js, napi-rs), loaded by node-gyp-build from the
+ * TypeScript compiled into dist (the build systems own build)
+ * @param name
+ * @param version
+ * @param build
+ */
+function nativeFiles(name, version, build) {
+    const target = name.replace(/^@[^/]+\//, '').replace(/[^A-Za-z0-9_]/g, '_');
+    const builds = {
+        gyp: {
+            files: gypFiles(target),
+            buildNative: 'node-gyp rebuild',
+            //Built when installed (node-gyp-build builds it without prebuilt binaries)
+            install: 'node-gyp-build',
+            sources: ['cpp', 'binding.gyp'],
+            dependencies: { 'node-addon-api': NATIVE_VERSIONS['node-addon-api'], 'node-gyp-build': NATIVE_VERSIONS['node-gyp-build'] },
+            devDependencies: { 'node-gyp': NATIVE_VERSIONS['node-gyp'] },
+            toolchain: 'Python and a C++ toolchain (the Xcode command line tools on macOS, build-essential on Linux, the Visual Studio Build Tools on Windows)'
+        },
+        cmake: {
+            files: cMakeFiles(target),
+            buildNative: 'cmake-js rebuild',
+            install: 'cmake-js compile',
+            sources: ['cpp', 'CMakeLists.txt'],
+            dependencies: { 'node-addon-api': NATIVE_VERSIONS['node-addon-api'], 'node-gyp-build': NATIVE_VERSIONS['node-gyp-build'], 'cmake-js': NATIVE_VERSIONS['cmake-js'] },
+            devDependencies: {},
+            toolchain: 'CMake and a C++ toolchain (the Xcode command line tools on macOS, build-essential on Linux, the Visual Studio Build Tools on Windows)'
+        },
+        rust: {
+            files: rustFiles(target, version),
+            buildNative: 'napi build --release --output-dir build/Release',
+            install: 'napi build --release --output-dir build/Release',
+            sources: ['rust', 'Cargo.toml', 'build.rs'],
+            dependencies: { 'node-gyp-build': NATIVE_VERSIONS['node-gyp-build'], '@napi-rs/cli': NATIVE_VERSIONS['@napi-rs/cli'] },
+            devDependencies: {},
+            toolchain: 'Rust (rustup, or the package manager of the system)'
+        }
+    };
+    const chosen = builds[build];
+    return {
+        'package.json': `${JSON.stringify({
+            name: name,
+            version: version,
+            private: true,
+            type: 'module',
+            main: 'dist/index.js',
+            types: 'dist/index.d.ts',
+            exports: { '.': { types: './dist/index.d.ts', default: './dist/index.js' } },
+            ...(build === 'gyp' ? { gypfile: true } : {}),
+            ...(build === 'rust' ? { napi: { binaryName: target } } : {}),
+            files: ['dist', '!dist/tests', ...chosen.sources],
+            scripts: {
+                //The addon is built when the package is installed (from its sources, without prebuilt binaries)
+                install: chosen.install,
+                clean: 'lakutata clean',
+                'clean:native': build === 'rust' ? 'lakutata clean build target' : 'lakutata clean build',
+                'build:native': chosen.buildNative,
+                build: 'tsc',
+                rebuild: 'npm run clean && npm run build:native && npm run build',
+                test: 'node --test "dist/tests/**/*.spec.js"'
+            },
+            dependencies: chosen.dependencies,
+            ...(Object.keys(chosen.devDependencies).length ? { devDependencies: chosen.devDependencies } : {})
+        }, null, 2)}\n`,
+        ...chosen.files,
+        'src/index.ts': `import {createRequire} from 'node:module'
+import path from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+/**
+ * The functions of the addon
+ */
+type Binding = {
+    greet(name: string): string
+}
+
+/**
+ * The addon built into build/Release, loaded from the directory of the package
+ */
+const binding: Binding = createRequire(import.meta.url)('node-gyp-build')(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'))
+
+/**
+ * Greet someone, in ${build === 'rust' ? 'Rust' : 'C++'}
+ * @param name
+ */
+export function Greet(name: string): string {
+    return binding.greet(name)
+}
+`,
+        'src/tests/index.spec.ts': `import {describe, it} from 'node:test'
+import assert from 'node:assert'
+import {Greet} from '../index.js'
+
+describe('${name}', (): void => {
+    it('greets in ${build === 'rust' ? 'Rust' : 'C++'}', (): void => {
+        assert.strictEqual(Greet('lakutata'), 'Hello, lakutata (native)')
+    })
+
+    it('throws the errors of the addon as JavaScript errors', (): void => {
+        assert.throws((): unknown => Greet(42 as unknown as string), ${build === 'rust' ? '/String/' : "{name: 'TypeError', message: 'The name must be a string'}"})
+    })
+})
+`,
+        'tsconfig.json': tsConfig('dist'),
+        'README.md': `# ${name}
+
+A native addon: ${NATIVE_GUIDES[build]}
+
+Node-API is stable across the versions of Node.js and Electron: the same addon runs in both without being rebuilt.
+\`lakutata package bundle\` and \`lakutata package exe\` ship it with the application.
+
+\`\`\`bash
+npm run rebuild   # build the addon (build/Release) and compile the TypeScript (dist)
+npm test          # run the tests
+\`\`\`
+
+A library built by its own Makefile (or its own build) is built before the addon by a script, then linked by it:
+\`"build:deps": "make -C deps/foo"\`, \`"build:native": "npm run build:deps && ${chosen.buildNative}"\`.
+
+Building the addon needs ${chosen.toolchain}.
+`
+    };
+}
+/**
+ * Add a package to the workspace of the current directory: packages/<name> (without its scope), of the version of the
+ * workspace; a package of the workspace may depend on it
+ * @param options
+ */
+export async function addPackage(options) {
+    if (!/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(options.name))
+        throw new Error(`"${options.name}" is not a name of package (lower case, digits, - . _ ~, an optional @scope/)`);
+    const workspace = await Workspace.find();
+    if (workspace.packages.some((pkg) => pkg.name === options.name))
+        throw new Error(`The workspace has already a package ${options.name}`);
+    const dependent = options.to === undefined ? undefined : workspace.packages.find((pkg) => pkg.name === options.to);
+    if (options.to !== undefined && !dependent)
+        throw new Error(`The workspace has no package ${options.to} (${workspace.packages.map((pkg) => pkg.name).join(', ')})`);
+    const directory = path.join(workspace.root, 'packages', options.name.replace(/^@[^/]+\//, ''));
+    if (existsSync(directory))
+        throw new Error(`${path.relative(process.cwd(), directory) || directory} exists already`);
+    const version = workspace.lerna?.data.version ?? workspace.manifest.data.version ?? '0.0.1';
+    const files = options.native ? nativeFiles(options.name, version, options.native) : libraryFiles(options.name, version);
+    for (const [file, content] of Object.entries(files)) {
+        await mkdir(path.dirname(path.join(directory, file)), { recursive: true });
+        await writeFile(path.join(directory, file), content);
+    }
+    if (dependent) {
+        dependent.manifest.data.dependencies = { ...(dependent.manifest.data.dependencies ?? {}), [options.name]: `^${version}` };
+        await dependent.manifest.write();
+    }
+    return { directory: directory, files: Object.keys(files), version: version, to: dependent?.name };
+}

package/dist/esm/lib/Builder.js

@@ -0,0 +1,21 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+/**
+ * The builder of a project: the one installed in the project (its node_modules, the ones of its workspace), else the one
+ * installed with the tool
+ * @param project
+ */
+export async function loadBuilder(project) {
+    for (const base of [path.join(project, 'package.json'), import.meta.url]) {
+        let entry;
+        try {
+            entry = createRequire(base).resolve('@lakutata/builder');
+        }
+        catch {
+            continue;
+        }
+        return await import(pathToFileURL(entry).href);
+    }
+    throw new Error('The builder of the applications is not installed: install it in the project (npm install --save-dev @lakutata/builder)');
+}

package/dist/esm/lib/Clean.js

@@ -0,0 +1,146 @@
+import { existsSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+/**
+ * The paths a clean never removes: the package itself, its sources, its dependencies and its manifest
+ */
+const PROTECTED = ['node_modules', 'src', 'package.json', '.git'];
+/**
+ * The text of a JSON with comments and trailing commas (a tsconfig.json) as JSON: the comments and the commas before a
+ * closing bracket are removed outside of the strings
+ * @param text
+ */
+function stripJSONC(text) {
+    let output = '';
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === '"') {
+            //A string, its escaped quotes included
+            let end = index + 1;
+            while (end < text.length && text[end] !== '"')
+                end += text[end] === '\\' ? 2 : 1;
+            output += text.slice(index, end + 1);
+            index = end;
+        }
+        else if (char === '/' && text[index + 1] === '/') {
+            while (index < text.length && text[index] !== '\n')
+                index++;
+            output += '\n';
+        }
+        else if (char === '/' && text[index + 1] === '*') {
+            index = text.indexOf('*/', index + 2);
+            if (index < 0)
+                break;
+            index++;
+        }
+        else if (char === ',') {
+            //A trailing comma: the next character, whitespaces and comments skipped, closes an object or an array
+            let next = index + 1;
+            for (;;) {
+                while (next < text.length && /\s/.test(text[next]))
+                    next++;
+                if (text[next] === '/' && text[next + 1] === '/')
+                    next = text.indexOf('\n', next) < 0 ? text.length : text.indexOf('\n', next);
+                else if (text[next] === '/' && text[next + 1] === '*')
+                    next = text.indexOf('*/', next + 2) < 0 ? text.length : text.indexOf('*/', next + 2) + 2;
+                else
+                    break;
+            }
+            if (text[next] !== '}' && text[next] !== ']')
+                output += char;
+        }
+        else {
+            output += char;
+        }
+    }
+    return output;
+}
+/**
+ * The file of a configuration extended: a path relative to the configuration, or a module (lakutata/tsconfig.json)
+ * @param from the configuration extending it
+ * @param specifier
+ */
+function extendedConfiguration(from, specifier) {
+    if (specifier.startsWith('.') || path.isAbsolute(specifier)) {
+        const file = path.resolve(path.dirname(from), specifier);
+        return [file, `${file}.json`].find((candidate) => existsSync(candidate) && !candidate.endsWith(path.sep));
+    }
+    const require = createRequire(from);
+    for (const candidate of [specifier, `${specifier}.json`, `${specifier}/tsconfig.json`]) {
+        try {
+            return require.resolve(candidate);
+        }
+        catch {
+            //The next form of the specifier
+        }
+    }
+    return undefined;
+}
+/**
+ * The output directories of a TypeScript configuration and of the ones it extends (outDir, declarationDir), absolute:
+ * each one relative to the configuration giving it, the closest configuration winning
+ * @param file
+ * @param depth
+ */
+async function configurationOutputs(file, depth = 0) {
+    const configuration = JSON.parse(stripJSONC(await readFile(file, 'utf8')));
+    let outputs = {};
+    const extended = configuration.extends === undefined ? [] : Array.isArray(configuration.extends) ? configuration.extends : [configuration.extends];
+    if (depth < 8) {
+        for (const specifier of extended) {
+            const parent = extendedConfiguration(file, specifier);
+            if (parent)
+                outputs = { ...outputs, ...await configurationOutputs(parent, depth + 1) };
+        }
+    }
+    for (const option of ['outDir', 'declarationDir']) {
+        const value = configuration.compilerOptions?.[option];
+        if (typeof value === 'string')
+            outputs[option] = path.resolve(path.dirname(file), value);
+    }
+    return outputs;
+}
+/**
+ * The output directories of the TypeScript configuration of a package (its tsconfig.json): outDir and declarationDir
+ * @param directory
+ * @return the directories, relative to the package
+ */
+export async function outputDirectories(directory) {
+    const file = path.join(directory, 'tsconfig.json');
+    if (!existsSync(file))
+        throw new Error(`${directory} has no tsconfig.json: give the paths removed (lakutata clean <paths...>)`);
+    const outputs = await configurationOutputs(file);
+    const directories = [...new Set([outputs.outDir, outputs.declarationDir].filter((output) => !!output))];
+    if (!directories.length)
+        throw new Error(`The tsconfig.json of ${directory} gives no outDir: give the paths removed (lakutata clean <paths...>)`);
+    return directories.map((output) => path.relative(directory, output));
+}
+/**
+ * Remove paths of a package (as rm -rf, on every platform): only the paths inside the package, never the package itself,
+ * its sources, its dependencies nor its manifest
+ * @param directory the directory of the package
+ * @param paths relative to the package
+ */
+export async function clean(directory, paths) {
+    const root = path.resolve(directory);
+    const targets = paths.map((target) => {
+        const absolute = path.resolve(root, target);
+        const relative = path.relative(root, absolute);
+        if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error(`${target} is not inside the package ${root}: it is not removed`);
+        if (PROTECTED.includes(relative.split(path.sep)[0]))
+            throw new Error(`${target} is protected (${PROTECTED.join(', ')}): it is not removed`);
+        return { relative: relative, absolute: absolute };
+    });
+    const result = { removed: [], missing: [] };
+    for (const target of targets) {
+        if (!existsSync(target.absolute)) {
+            result.missing.push(target.relative);
+            continue;
+        }
+        await rm(target.absolute, { recursive: true, force: true });
+        result.removed.push(target.relative);
+    }
+    return result;
+}

package/dist/esm/lib/Environment.js

@@ -0,0 +1,11 @@
+/**
+ * The environment the tool was started with: the application of the tool sets some variables (NODE_ENV from its mode…),
+ * the commands it runs (the scripts of the packages, the installations) are given the environment of the user
+ */
+export const LaunchEnvironment = { ...process.env };
+//The commands of the migrations (MIGRATION_GENERATE, MIGRATION_RUN…) are given to the applications of the projects, not
+//to the tool, an application of lakutata too: the tool run by a script of an application started by a migration command
+//(lakutata clean in its build) does its own command; the commands it runs are still given them (LaunchEnvironment)
+for (const name of Object.keys(process.env))
+    if (name.toUpperCase().startsWith('MIGRATION_'))
+        delete process.env[name];