@lakutata/cli 3.1.4 → 3.1.6

package/dist/esm/controllers/NwjsController.js

@@ -0,0 +1,128 @@
+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 { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { Controller } from 'lakutata/com/entrypoint';
+import { CLIAction } from 'lakutata/decorator/ctrl';
+import { NwjsRunDTO } from '../dtos/NwjsRunDTO.js';
+import { NwjsUseDTO } from '../dtos/NwjsUseDTO.js';
+import { NwjsVersionsDTO } from '../dtos/NwjsVersionsDTO.js';
+import { loadBuilder } from '../lib/Builder.js';
+import { done, step } from '../lib/Output.js';
+/**
+ * The last release of NW.js running on Windows 7, 8 and 8.1 (Chromium 109)
+ */
+const WINDOWS_7 = '0.72.0';
+/**
+ * Whether a version of NW.js is at most another one
+ * @param version
+ * @param other
+ */
+function atMost(version, other) {
+    const parts = (value) => value.split('.').map((part) => parseInt(part, 10) || 0);
+    const [a, b] = [parts(version), parts(other)];
+    for (let index = 0; index < 3; index++)
+        if (a[index] !== b[index])
+            return (a[index] ?? 0) < (b[index] ?? 0);
+    return true;
+}
+/**
+ * The systems a release of NW.js runs on, as its users see them
+ * @param release
+ */
+function systemsOf(release) {
+    const windows = atMost(release.version, WINDOWS_7) ? 'Windows 7 or later' : 'Windows 10 or later';
+    const mac = release.platforms.includes('osx-arm64') ? 'macOS (Intel, Apple silicon)' : 'macOS (Intel; Apple silicon through Rosetta)';
+    const linux = `Linux (${release.platforms.filter((platform) => platform.startsWith('linux-')).map((platform) => platform.slice(6)).join(', ')})`;
+    return `${windows}, ${mac}, ${linux}`;
+}
+/**
+ * The commands of the applications of NW.js: its releases, the one of the application, the run of the development
+ */
+export class NwjsController extends Controller {
+    async versions(input) {
+        const { nwjsReleases } = await loadBuilder(process.cwd());
+        const releases = (await nwjsReleases()).filter((release) => !atMost(release.node, '18.9.99'));
+        const shown = input.all ? releases : releases.filter((release, index) => index < 10 || release.version === WINDOWS_7);
+        for (const release of shown) {
+            const marks = [release === releases[0] ? 'latest' : '', release.version === WINDOWS_7 ? 'win7: the last one running on Windows 7, 8 and 8.1' : ''].filter(Boolean).join(', ');
+            step(`${release.version.padEnd(9)} ${release.date.padEnd(11)} Node.js ${release.node.padEnd(8)} Chromium ${release.chromium.split('.')[0]}  ${release.platforms.join(' ')}${marks ? `  (${marks})` : ''}`);
+        }
+        return undefined;
+    }
+    async use(input) {
+        const { nwjsRelease, downloadNwjs } = await loadBuilder(process.cwd());
+        const release = await nwjsRelease(input.version);
+        const file = path.join(process.cwd(), 'package.json');
+        const manifest = JSON.parse(readFileSync(file, 'utf8'));
+        manifest.lakutata = { ...manifest.lakutata, nwjs: { ...manifest.lakutata?.nwjs, version: release.version } };
+        writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+        //What the builds of the user interface and of the application are made for
+        writeFileSync(path.join(process.cwd(), 'nwjs.json'), `${JSON.stringify({ version: release.version, node: release.node, chromium: release.chromium }, null, 2)}\n`);
+        done(`NW.js ${release.version}: Node.js ${release.node}, Chromium ${release.chromium}`);
+        step(`Runs on ${systemsOf(release)}`);
+        if (input.download) {
+            const runtime = await downloadNwjs({ version: release.version, flavor: 'sdk', progress: (line) => step(`Downloading ${line}`) });
+            done(`Downloaded NW.js ${runtime.version} (sdk, ${runtime.platform})`);
+        }
+        return undefined;
+    }
+    async run(input) {
+        const { stageNwjsApp, downloadNwjs } = await loadBuilder(process.cwd());
+        const stage = await stageNwjsApp({ project: process.cwd(), outdir: path.join('.nwjs', 'app'), version: input.release });
+        if (stage.addons.rebuilt.length)
+            step(`Native addons built for NW.js ${stage.release.version} (${stage.platform}): ${stage.addons.rebuilt.join(', ')}`);
+        if (stage.addons.renamed.length)
+            step(`Native addons loading the Node.js of NW.js (node.dll): ${stage.addons.renamed.join(', ')}`);
+        const runtime = await downloadNwjs({ version: stage.release.version, flavor: input.flavor, progress: (line) => step(`Downloading ${line}`) });
+        step(`NW.js ${runtime.version} (${runtime.flavor}, ${runtime.platform}): Node.js ${runtime.node}, Chromium ${runtime.chromium.split('.')[0]}`);
+        const code = await new Promise((resolve, reject) => {
+            const child = spawn(runtime.executable, [stage.directory, ...input.args ?? []], { stdio: 'inherit' });
+            //NW.js ends with the command: at once when the command is stopped by a signal sent to it only (a runner of the
+            //scripts), the run then done
+            const stop = () => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill();
+            };
+            const events = ['exit', 'SIGINT', 'SIGTERM', 'SIGHUP'];
+            for (const event of events)
+                process.once(event, stop);
+            child.once('error', reject);
+            //Stopped by a signal (Ctrl-C in the terminal): a normal end of the run
+            child.once('exit', (exitCode, signal) => {
+                for (const event of events)
+                    process.off(event, stop);
+                resolve(signal ? 0 : exitCode ?? 1);
+            });
+        });
+        if (code !== 0)
+            throw new Error(`NW.js exited with ${code}`);
+        return undefined;
+    }
+}
+__decorate([
+    CLIAction('nwjs versions', NwjsVersionsDTO, { description: 'List the releases of NW.js lakutata runs on: their Node.js, their Chromium, their systems' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsVersionsDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "versions", null);
+__decorate([
+    CLIAction('nwjs use <version>', NwjsUseDTO, { description: 'Give the application of the current directory its version of NW.js (lakutata.nwjs), and write its Node.js and its Chromium into nwjs.json' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsUseDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "use", null);
+__decorate([
+    CLIAction('nwjs run [args...]', NwjsRunDTO, { description: 'Run the compiled application of the current directory in NW.js (the build with its developer tools, by default)' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [NwjsRunDTO]),
+    __metadata("design:returntype", Promise)
+], NwjsController.prototype, "run", null);

package/dist/esm/controllers/PackController.js

@@ -29,7 +29,7 @@ function megabytes(size) {
 export class PackController extends Controller {
     async bundle(input) {
         const { bundleProject } = await loadBuilder(process.cwd());
-        const result = await bundleProject({ project: process.cwd(), entry: input.entry, outfile: input.outfile, minify: input.minify, external: input.external });
+        const result = await bundleProject({ project: process.cwd(), entry: input.entry, outfile: input.outfile, minify: input.minify, external: input.external, node: input.node });
         done(`${path.relative(process.cwd(), result.outfile)} (${megabytes(result.size)}): node ${path.relative(process.cwd(), result.outfile)}`);
         //The native addons and the scripts of the workers are next to the bundle, which is distributed with them
         if (result.nativeDirectory) {
@@ -49,7 +49,7 @@ export class PackController extends Controller {
     }
     async executable(input) {
         const { buildExecutable } = await loadBuilder(process.cwd());
-        const result = await buildExecutable({ project: process.cwd(), entry: input.entry, outdir: input.outdir, minify: input.minify, external: input.external, runtime: input.runtime, layout: input.layout });
+        const result = await buildExecutable({ project: process.cwd(), entry: input.entry, outdir: input.outdir, minify: input.minify, external: input.external, runtime: input.runtime, layout: input.layout, nodeProgram: input.nodeProgram });
         step(`${result.runtime} embedded`);
         if (result.native.length)
             step(result.directory ? `Native addons next to the executable: ${result.native.join(', ')}` : `Native addons embedded, extracted at the first run: ${result.native.join(', ')}`);
@@ -68,12 +68,21 @@ export class PackController extends Controller {
     }
     async installer(input) {
         const { buildInstaller } = await loadBuilder(process.cwd());
-        const result = await buildInstaller({ project: process.cwd(), targets: input.target, outdir: input.outdir, entry: input.entry, minify: input.minify, external: input.external });
-        step(`${result.executable.runtime} embedded`);
-        if (result.executable.native.length)
-            step(`Native addons: ${result.executable.native.join(', ')}`);
-        if (result.executable.resources.length)
-            step(`Resources: ${result.executable.resources.join(', ')}`);
+        const result = await buildInstaller({ project: process.cwd(), targets: input.target, outdir: input.outdir, entry: input.entry, minify: input.minify, external: input.external, nodeProgram: input.nodeProgram, arch: input.arch, progress: (line) => step(`Downloading ${line}`) });
+        if (result.nwjs) {
+            step(`NW.js ${result.nwjs.runtime.version} (${result.nwjs.runtime.platform}): ${path.basename(result.nwjs.directory)}`);
+            if (result.nwjs.stage.addons.rebuilt.length)
+                step(`Native addons built for NW.js: ${result.nwjs.stage.addons.rebuilt.join(', ')}`);
+            if (result.nwjs.stage.addons.renamed.length)
+                step(`Native addons loading the Node.js of NW.js (node.dll): ${result.nwjs.stage.addons.renamed.join(', ')}`);
+        }
+        if (result.executable) {
+            step(`${result.executable.runtime} embedded`);
+            if (result.executable.native.length)
+                step(`Native addons: ${result.executable.native.join(', ')}`);
+            if (result.executable.resources.length)
+                step(`Resources: ${result.executable.resources.join(', ')}`);
+        }
         for (const warning of result.warnings)
             warn(warning);
         for (const file of result.files)

package/dist/esm/dtos/BundleDTO.js

@@ -27,3 +27,7 @@ __decorate([
     Expect(DTO.Array(DTO.String()).optional().description('The modules left out of the bundle, loaded at run time from a node_modules next to it (the native addons are handled)')),
     __metadata("design:type", Array)
 ], BundleDTO.prototype, "external", void 0);
+__decorate([
+    Expect(DTO.String().pattern(/^v?\d+(\.\d+){0,2}$/).optional().description('The version of Node.js running the bundle, whose syntax it is written in (18.10 for NW.js 0.70; the version running the command by default)')),
+    __metadata("design:type", String)
+], BundleDTO.prototype, "node", void 0);

package/dist/esm/dtos/CreateProjectDTO.js

@@ -19,6 +19,10 @@ __decorate([
     Expect(DTO.String().optional().pattern(/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/).description('The ID of the application (a package name), its name in lower case by default')),
     __metadata("design:type", String)
 ], CreateProjectDTO.prototype, "id", void 0);
+__decorate([
+    Expect(DTO.String().optional().pattern(/^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/).description('The id of the application on the mobile systems (reverse domain name: com.acme.shop), for the mobile templates: com.example.<name> by default, which the stores refuse')),
+    __metadata("design:type", String)
+], CreateProjectDTO.prototype, "bundleId", void 0);
 __decorate([
     Expect(DTO.String().optional().default('default').description('The template: the name of an official template (lakutata templates lists them), npm:<package>, github:<owner>/<repo> or a directory')),
     __metadata("design:type", String)

package/dist/esm/dtos/ExecutableDTO.js

@@ -35,3 +35,7 @@ __decorate([
     Expect(DTO.String().valid('file', 'directory').optional().default('file').description('One file, its native addons and its resources embedded (file, by default), or a directory: the executable and its native addons and resources next to it (directory)')),
     __metadata("design:type", String)
 ], ExecutableDTO.prototype, "layout", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The node program embedded in the executable (Node.js 20.12, 21.7 or later): another Node.js than the one running the command, to make the executable from an older Node.js (the bundle is written in the syntax of the node program)')),
+    __metadata("design:type", String)
+], ExecutableDTO.prototype, "nodeProgram", void 0);

package/dist/esm/dtos/InstallerDTO.js

@@ -12,7 +12,7 @@ import { Expect } from 'lakutata/decorator/dto';
 export class InstallerDTO extends DTO {
 }
 __decorate([
-    Expect(DTO.Array(DTO.String()).optional().description('The installers made: deb, rpm, apk, archlinux, tar.gz on Linux, pkg, tar.gz on macOS, nsis, msi, zip on Windows (the lakutata.installer of the package.json by default)')),
+    Expect(DTO.Array(DTO.String()).optional().description('The installers made: deb, rpm, apk, archlinux, tar.gz on Linux, pkg, dmg (the applications of NW.js), tar.gz on macOS, nsis, msi, zip on Windows (the lakutata.installer of the package.json by default)')),
     __metadata("design:type", Array)
 ], InstallerDTO.prototype, "target", void 0);
 __decorate([
@@ -31,3 +31,11 @@ __decorate([
     Expect(DTO.Array(DTO.String()).optional().description('The modules left out of the bundle')),
     __metadata("design:type", Array)
 ], InstallerDTO.prototype, "external", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The node program embedded in the executable (Node.js 20.12, 21.7 or later): another Node.js than the one running the command, to make the executable from an older Node.js (the bundle is written in the syntax of the node program)')),
+    __metadata("design:type", String)
+], InstallerDTO.prototype, "nodeProgram", void 0);
+__decorate([
+    Expect(DTO.String().valid('x64', 'ia32', 'arm64').optional().description('The architecture of an application of NW.js (the one of this machine by default): ia32 for the 32-bit systems of Windows (Windows 7)')),
+    __metadata("design:type", String)
+], InstallerDTO.prototype, "arch", void 0);

package/dist/esm/dtos/MobileDeployDTO.js

@@ -0,0 +1,25 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class MobileDeployDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().valid('android', 'ios', 'harmony').required().description('The system: android (an emulator or a device, the debug build of the application), ios (a simulator) or harmony (an emulator or a device, the debug build of the application)')),
+    __metadata("design:type", String)
+], MobileDeployDTO.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The emulator or the device of Android (its serial, adb devices) or of HarmonyOS (its target, hdc list targets), the simulator of iOS (its UDID or its name, xcrun simctl list); the one running by default')),
+    __metadata("design:type", String)
+], MobileDeployDTO.prototype, "device", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false).description('Watch the files of the application: when they change, run its build script (npm run build) and deploy it again, until Ctrl+C')),
+    __metadata("design:type", Boolean)
+], MobileDeployDTO.prototype, "watch", void 0);

package/dist/esm/dtos/MobileNodeDTO.js

@@ -0,0 +1,21 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class MobileNodeDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().valid('android', 'ios', 'harmony').required().description('The system the libnode is downloaded for: android, ios or harmony')),
+    __metadata("design:type", String)
+], MobileNodeDTO.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The architectures of Android downloaded for, separated by commas (arm64-v8a,armeabi-v7a,x86_64); arm64-v8a,x86_64 by default')),
+    __metadata("design:type", String)
+], MobileNodeDTO.prototype, "abis", void 0);

package/dist/esm/dtos/MobileRunDTO.js

@@ -0,0 +1,21 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class MobileRunDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().valid('android', 'ios', 'harmony').required().description('The system: android (an emulator or a device), ios (a simulator) or harmony (an emulator or a device)')),
+    __metadata("design:type", String)
+], MobileRunDTO.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The emulator or the device of Android (its serial, adb devices) or of HarmonyOS (its target, hdc list targets), the simulator of iOS (its UDID or its name, xcrun simctl list devices); the one running by default, else the newest iPhone for iOS')),
+    __metadata("design:type", String)
+], MobileRunDTO.prototype, "device", void 0);

package/dist/esm/dtos/MobileStageDTO.js

@@ -0,0 +1,25 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class MobileStageDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().valid('android', 'ios', 'harmony').required().description('The system the Node.js project is made for: android, ios or harmony')),
+    __metadata("design:type", String)
+], MobileStageDTO.prototype, "platform", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(true).description('Minify the bundle (true by default)')),
+    __metadata("design:type", Boolean)
+], MobileStageDTO.prototype, "minify", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The architectures of Android the native addons are built for, separated by commas (arm64-v8a,x86_64); those of the libnode by default')),
+    __metadata("design:type", String)
+], MobileStageDTO.prototype, "abis", void 0);

package/dist/esm/dtos/NwjsRunDTO.js

@@ -0,0 +1,25 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsRunDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.Array(DTO.String()).optional().description('The arguments given to the application, after -- (lakutata nwjs run -- --ui=http://localhost:5173)')),
+    __metadata("design:type", Array)
+], NwjsRunDTO.prototype, "args", void 0);
+__decorate([
+    Expect(DTO.String().optional().description('The release of NW.js run: a version, latest or win7 (the version of lakutata.nwjs by default)')),
+    __metadata("design:type", String)
+], NwjsRunDTO.prototype, "release", void 0);
+__decorate([
+    Expect(DTO.String().valid('sdk', 'normal').optional().default('sdk').description('The flavor of NW.js: sdk (with its developer tools, by default) or normal (the one shipped to the users)')),
+    __metadata("design:type", String)
+], NwjsRunDTO.prototype, "flavor", void 0);

package/dist/esm/dtos/NwjsUseDTO.js

@@ -0,0 +1,21 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsUseDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.String().required().description('The version of NW.js: a version (0.119.2), latest, or win7 (0.72.0, the last one running on Windows 7, 8 and 8.1)')),
+    __metadata("design:type", String)
+], NwjsUseDTO.prototype, "version", void 0);
+__decorate([
+    Expect(DTO.Boolean().optional().default(false).description('Download the development build of NW.js (with its developer tools) for this machine now')),
+    __metadata("design:type", Boolean)
+], NwjsUseDTO.prototype, "download", void 0);

package/dist/esm/dtos/NwjsVersionsDTO.js

@@ -0,0 +1,17 @@
+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 { DTO } from 'lakutata';
+import { Expect } from 'lakutata/decorator/dto';
+export class NwjsVersionsDTO extends DTO {
+}
+__decorate([
+    Expect(DTO.Boolean().optional().default(false).description('List every release lakutata runs on (the latest ten and the one of Windows 7 by default)')),
+    __metadata("design:type", Boolean)
+], NwjsVersionsDTO.prototype, "all", void 0);

package/dist/esm/lib/AddPackage.js

@@ -383,7 +383,9 @@ function nativeFiles(name, version, build, packageManager) {
             name: name,
             version: version,
             private: true,
-            type: 'module',
+            //CommonJS: the bundles of the applications are CommonJS and require it, which loads an ES module only on
+            //Node.js 20.19, 22.12 and later
+            type: 'commonjs',
             main: 'dist/index.js',
             types: 'dist/index.d.ts',
             exports: { '.': { types: './dist/index.d.ts', default: './dist/index.js' } },
@@ -406,7 +408,6 @@ function nativeFiles(name, version, build, packageManager) {
         ...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
@@ -418,7 +419,7 @@ type Binding = {
 /**
  * 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)), '..'))
+const binding: Binding = createRequire(__filename)('node-gyp-build')(path.resolve(__dirname, '..'))
 
 /**
  * Greet someone, in ${build === 'rust' ? 'Rust' : 'C++'}

package/dist/esm/lib/Output.js

@@ -1,11 +1,20 @@
-import { styleText } from 'node:util';
+import util from 'node:util';
+/**
+ * The styles of the output, and their codes of the terminals (where util.styleText is missing: before Node.js 20.12)
+ */
+const STYLES = { bold: [1, 22], red: [31, 39], green: [32, 39], yellow: [33, 39], blue: [34, 39], magenta: [35, 39], cyan: [36, 39] };
 /**
  * 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;
+    if (!process.stdout.isTTY || process.env.NO_COLOR)
+        return text;
+    //node-compat: util.styleText
+    if (typeof util.styleText === 'function')
+        return util.styleText(style, text);
+    return `\u001b[${STYLES[style][0]}m${text}\u001b[${STYLES[style][1]}m`;
 }
 /**
  * Print a step done

package/dist/esm/lib/ProjectCreator.js

@@ -119,6 +119,23 @@ let ProjectCreator = class ProjectCreator extends Component {
                 await writeFile(target, filled);
         }
     }
+    /**
+     * Whether a template (its files, those of its features) holds a field ({$APP_BUNDLE_ID}…)
+     * @param template
+     * @param field
+     */
+    async uses(template, field) {
+        for (const root of [template.root, template.featuresDirectory]) {
+            if (!root || !existsSync(root))
+                continue;
+            for (const file of await listFiles(root)) {
+                const content = await readFile(path.join(root, file));
+                if (isText(content) && content.toString('utf8').includes(field))
+                    return true;
+            }
+        }
+        return false;
+    }
     /**
      * Get the files of a template
      * @param source
@@ -151,6 +168,7 @@ let ProjectCreator = class ProjectCreator extends Component {
         await this.fill(plan.directory, files, {
             $APP_NAME: plan.name,
             $APP_ID: plan.id,
+            $APP_BUNDLE_ID: plan.bundleId,
             $APP_DESC: plan.description,
             $APP_AUTHOR: plan.author,
             $APP_LICENSE: plan.license,

package/dist/esm/lib/TemplateCatalog.js

@@ -32,7 +32,10 @@ export const BUILTIN_TEMPLATES = [
     { name: 'web-vue', description: 'An HTTP API serving a Vue single-page application (Vite)', package: '@lakutata/template-web-vue', features: ['i18n', 'installer'] },
     { name: 'web-nuxt', description: 'An HTTP API serving a Nuxt application from the same process', package: '@lakutata/template-web-nuxt', features: ['i18n', 'installer'] },
     { name: 'electron-react', description: 'A desktop application: Electron, its main process serving a React renderer over IPC', package: '@lakutata/template-electron-react', features: ['i18n'] },
-    { name: 'electron-vue', description: 'A desktop application: Electron, its main process serving a Vue renderer over IPC', package: '@lakutata/template-electron-vue', features: ['i18n'] }
+    { name: 'electron-vue', description: 'A desktop application: Electron, its main process serving a Vue renderer over IPC', package: '@lakutata/template-electron-vue', features: ['i18n'] },
+    { name: 'nwjs-react', description: 'A desktop application: NW.js, its background script serving a React user interface isolated in a webview', package: '@lakutata/template-nwjs-react', features: ['i18n', 'win7'] },
+    { name: 'nwjs-vue', description: 'A desktop application: NW.js, its background script serving a Vue user interface isolated in a webview', package: '@lakutata/template-nwjs-vue', features: ['i18n', 'win7'] },
+    { name: 'mobile-react', description: 'A mobile application (Android, iOS, HarmonyOS): React Native, the Node.js of the application serving its user interface', package: '@lakutata/template-mobile-react', features: ['i18n'] }
 ];
 /**
  * How long the catalog is kept, 1 day

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

@@ -66,7 +66,8 @@ export async function runScript(workspace, script, options = {}) {
                 dependencies.delete(name);
         return [pkg.name, dependencies];
     }));
-    const concurrency = options.parallel ? Math.max(1, selected.length) : Math.max(1, options.concurrency ?? os.availableParallelism());
+    //node-compat: os.availableParallelism
+    const concurrency = options.parallel ? Math.max(1, selected.length) : Math.max(1, options.concurrency ?? (typeof os.availableParallelism === 'function' ? os.availableParallelism() : os.cpus().length));
     const width = Math.max(0, ...selected.map((pkg) => pkg.name.length));
     const done = new Set();
     //The packages depending on a failed package, not run