@lakutata/builder 3.1.1 → 3.1.3

package/dist/esm/lib/Bundle.js

@@ -98,7 +98,7 @@ export async function bundleProject(options) {
         throw new Error(`The entry ${path.relative(process.cwd(), entry) || entry} does not exist: build the project first`);
     const outfile = path.resolve(project, options.outfile ?? path.join('dist', `${name}.cjs`));
     const collector = new NativeCollector(project, options.runtime);
-    const files = new FileCollector(project);
+    const files = new FileCollector(project, { packageOf: (file) => collector.addonPackageOf(file), nativeFilesOf: (root, directory) => collector.nativeFilesOf(root, directory) });
     //esbuild is loaded by the commands which need it
     const { build } = await import('esbuild');
     //The application, and each script of its workers (the bundler does not follow new Worker()): their native packages
@@ -147,9 +147,15 @@ export async function bundleProject(options) {
     const resourcesDirectory = path.resolve(path.dirname(outfile), options.directories?.resources ?? `${base}.resources`);
     //The scripts of the workers, until the ones they start are bundled too
     const scripts = new Map();
+    //The files of every bundle, the application's and its workers'
+    const inputs = new Set(application.inputs);
     for (let pending = [...files.scripts]; pending.length; pending = [...files.scripts].filter(([at]) => !scripts.has(at))) {
-        for (const [at, script] of pending)
-            scripts.set(at, (await bundle(script, path.join(nativeDirectory, ...at.split('/')))).code);
+        for (const [at, script] of pending) {
+            const bundled = await bundle(script, path.join(nativeDirectory, ...at.split('/')));
+            scripts.set(at, bundled.code);
+            for (const input of bundled.inputs)
+                inputs.add(input);
+        }
     }
     files.warnBundled(application.inputs);
     const embedded = options.native === 'embedded';
@@ -221,6 +227,6 @@ export async function bundleProject(options) {
         resourcesDirectory: resources.files.length && !embedded ? resourcesDirectory : undefined,
         workers: [...new Set([...scripts.keys()].map((at) => files.nameOf(files.scripts.get(at))))].sort(),
         files: [...files.roots].filter((root) => !files.scriptPaths().has(root)).map((root) => files.nameOf(root)).sort(),
-        warnings: files.warnings
+        warnings: [...files.warnings, ...collector.unshippedAddons(inputs, files.files.values())]
     };
 }

package/dist/esm/lib/Files.js

@@ -291,8 +291,10 @@ export class FileCollector {
     /**
      * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
      * real path)
+     * @param addons The packages sharing the framework and holding addons
      */
-    constructor(project) {
+    constructor(project, addons) {
+        this.addons = addons;
         /**
          * The scripts: their paths in the native tree, and their files
          */
@@ -354,6 +356,7 @@ export class FileCollector {
         const directory = path.resolve(path.join(found.base ?? path.dirname(file), prefix.slice(0, cut + 1)));
         const rest = [...prefix.slice(cut + 1) ? [{ text: prefix.slice(cut + 1) }] : [], ...found.parts.slice(leading.length)];
         const targets = { directory: directory, rest: rest, scripts: [], files: [], roots: [] };
+        const addons = this.addons?.packageOf(file);
         //A file: bundled when it is a script, copied otherwise; a directory of data: its files copied
         const take = (at, strict) => {
             const stats = statSync(at);
@@ -362,8 +365,19 @@ export class FileCollector {
                 targets.roots.push(at);
             }
             else if (stats.isDirectory()) {
-                //A directory holding the module (the application, its packages), or holding code: not shipped
-                if ((file + path.sep).startsWith(at + path.sep)) {
+                //A directory of the package of addons of the module, bundled with the application: its native files
+                //(its addons found from it, as node-gyp-build finds them)
+                if (addons && (at + path.sep).startsWith(addons + path.sep)) {
+                    targets.files.push(...this.addons.nativeFilesOf(addons, at));
+                    targets.roots.push(at);
+                    //The directory named exactly (the package above the module): the files are named from it
+                    if (strict) {
+                        targets.directory = at;
+                        targets.rest = [];
+                    }
+                }
+                else if ((file + path.sep).startsWith(at + path.sep)) {
+                    //A directory holding the module (the application, its packages), or holding code: not shipped
                     if (strict)
                         targets.refused = 'ancestor';
                 }
@@ -452,8 +466,29 @@ export class FileCollector {
         const members = new Map();
         const constructors = new Set();
         const namespaces = new Set();
+        //The names of the properties (a.__dirname, {__dirname: a}, {__dirname}), which are not to be rewritten; whether the
+        //module declares a __dirname of its own (a variable, a parameter: the name is not the directory of the module)
+        const properties = new Set();
+        let declaresDirname = false;
+        const names = (pattern) => {
+            let found = false;
+            walk(pattern, (node) => {
+                if (node.type === 'Identifier' && node.name === '__dirname')
+                    found = true;
+            });
+            return found;
+        };
         const remember = (values, name, value) => values.set(name, values.has(name) ? null : value);
         walk(program, (node) => {
+            if (node.type === 'MemberExpression' && !node.computed)
+                properties.add(node.property);
+            if (node.type === 'Property' && !node.computed) {
+                properties.add(node.key);
+                if (node.shorthand)
+                    properties.add(node.value);
+            }
+            if ((node.type === 'VariableDeclarator' && names(node.id)) || (node.type === 'CatchClause' && node.param && names(node.param)) || (/Function/.test(node.type) && node.params.some(names)))
+                declaresDirname = true;
             if (node.type === 'ImportDeclaration' && WORKER_THREADS.has(node.source.value)) {
                 for (const specifier of node.specifiers) {
                     if (specifier.type === 'ImportSpecifier' && (specifier.imported.name ?? specifier.imported.value) === 'Worker')
@@ -484,11 +519,15 @@ export class FileCollector {
             if (node.type === 'AssignmentExpression' && node.operator === '=' && node.left.type === 'MemberExpression' && node.left.object.type === 'ThisExpression' && !node.left.computed)
                 remember(members, node.left.property.name, node.right);
         });
-        //The paths to files, wherever they are written
+        //The paths to files, wherever they are written. In a module of a package of addons bundled with the application,
+        //the directory of the module itself too (given to node-gyp-build): the native files of the package are there, in
+        //the tree (a __dirname the module declares is its own: the value it is given, rewritten when it is the directory)
+        const ownDirectory = !!this.addons?.packageOf(file);
+        const isOwnDirectory = (node) => ownDirectory && isDirname(node) && !properties.has(node) && !(node.type === 'Identifier' && declaresDirname);
         const edits = [];
         const followed = new Set();
         walk(program, (node) => {
-            const found = scriptPathOf(node, source, file);
+            const found = scriptPathOf(node, source, file) ?? (isOwnDirectory(node) ? { kind: 'path', parts: [] } : undefined);
             if (!found)
                 return true;
             const targets = this.targetsOf(found, file);

package/dist/esm/lib/Native.js

@@ -227,7 +227,7 @@ export class NativeCollector {
     }
     /**
      * Whether a package is left out of the bundle: it holds addons, or one of its dependencies does (it loads them,
-     * with computed paths often), and it is not the project
+     * with computed paths often), and it is neither the project nor a package sharing the framework
      * @param root
      */
     isNative(root) {
@@ -236,14 +236,68 @@ export class NativeCollector {
         const info = this.package(root);
         if (!info)
             return false;
-        if (info.addons)
-            return true;
         //A package of the framework, or built on it, shares it with the application: bundled with it (one copy of its
-        //classes, its container), its native dependencies loaded by their names, which the bundler follows
+        //classes, its container), its native dependencies loaded by their names, which the bundler follows, and its own
+        //addons loaded from the tree (a require of the addon, or a path from its module: the bundler follows both)
         if (sharesFramework(info.manifest))
             return false;
+        if (info.addons)
+            return true;
         return this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
     }
+    /**
+     * The package sharing the framework and holding addons a file belongs to: bundled with the application, the paths
+     * to its own directories ship their native files (its addons, its manifest, its data)
+     * @param file
+     * @returns its directory, undefined for a file of another package
+     */
+    addonPackageOf(file) {
+        const root = this.packageRoot(file);
+        if (!root || root === this.project)
+            return undefined;
+        const info = this.package(root);
+        return info?.addons && sharesFramework(info.manifest) ? root : undefined;
+    }
+    /**
+     * The native files of a directory of a package holding addons: the files node loads at run time (its addons, its
+     * libraries, its manifest, its data), without its scripts (bundled) and what node never loads
+     * @param root the directory of the package
+     * @param directory
+     */
+    nativeFilesOf(root, directory) {
+        const cargo = existsSync(path.join(root, 'Cargo.toml'));
+        return packageFiles(directory).filter((file) => {
+            const relative = path.relative(root, file).split(path.sep).join('/');
+            return !SCRIPT.test(file) && !UNUSED.test(file) && !BUILD_FILES.test(relative) && !(cargo && relative.startsWith('target/'));
+        });
+    }
+    /**
+     * The addons of the packages sharing the framework bundled with the application which are not shipped: none of
+     * their addons is loaded by a require or a path the bundler follows (they would not be found at run time)
+     * @param inputs the files bundled
+     * @param shipped the files of the tree (the addons loaded by a require, the files read by a path from a module)
+     * @returns the warnings, one by package
+     */
+    unshippedAddons(inputs, shipped) {
+        const files = new Set([...shipped, ...this.addons.values()]);
+        const roots = new Set();
+        for (const input of inputs) {
+            const root = this.packageRoot(input);
+            if (root && root !== this.project)
+                roots.add(root);
+        }
+        const warnings = [];
+        for (const root of [...roots].sort()) {
+            const info = this.package(root);
+            if (!info?.addons || !sharesFramework(info.manifest))
+                continue;
+            const addons = packageFiles(root).filter((file) => ADDON.test(file));
+            if (addons.some((addon) => files.has(addon)))
+                continue;
+            warnings.push(`${info.name}: its native addon (${addons.map((addon) => path.relative(root, addon).split(path.sep).join('/')).join(', ')}) is not shipped: the bundler does not follow how it is loaded. A package built on the framework is bundled with the application: load its addon by a require (require('./build/Release/addon.node')) or by a path from its module (path.join(__dirname, 'prebuilds', \`\${process.platform}-\${process.arch}\`, 'addon.node'), new URL('./addon.node', import.meta.url))`);
+        }
+        return warnings;
+    }
     /**
      * Resolve an import as esbuild does
      * @param build

package/dist/types/lib/Files.d.ts

@@ -27,6 +27,14 @@ type ScriptPath = {
      */
     base?: string;
 };
+/**
+ * The packages sharing the framework and holding addons, bundled with the application: the package of a file, the
+ * native files of one of its directories (shipped by the paths to its own directories)
+ */
+export type AddonPackages = {
+    packageOf(file: string): string | undefined;
+    nativeFilesOf(root: string, directory: string): string[];
+};
 /**
  * What a path from a module gives: the directory of its pattern, the parts from it, the scripts to bundle and the files
  * to copy (the files of its directories of data), or why it cannot be shipped
@@ -54,6 +62,7 @@ type Targets = {
  * paths their users give)
  */
 export declare class FileCollector {
+    protected readonly addons?: AddonPackages | undefined;
     /**
      * The scripts: their paths in the native tree, and their files
      */
@@ -71,8 +80,9 @@ export declare class FileCollector {
     /**
      * @param project The directory of the project: the scripts are named from it (as the modules the bundler gives, its
      * real path)
+     * @param addons The packages sharing the framework and holding addons
      */
-    constructor(project: string);
+    constructor(project: string, addons?: AddonPackages | undefined);
     /**
      * The key of a directory in the tree ("/" separated): its path from the project; outside of the project (the
      * packages of a workspace, linked), its path from the node_modules holding it, else a hash of its path (the paths of

package/dist/types/lib/Native.d.ts

@@ -121,10 +121,32 @@ export declare class NativeCollector {
     }[];
     /**
      * Whether a package is left out of the bundle: it holds addons, or one of its dependencies does (it loads them,
-     * with computed paths often), and it is not the project
+     * with computed paths often), and it is neither the project nor a package sharing the framework
      * @param root
      */
     protected isNative(root: string | undefined): root is string;
+    /**
+     * The package sharing the framework and holding addons a file belongs to: bundled with the application, the paths
+     * to its own directories ship their native files (its addons, its manifest, its data)
+     * @param file
+     * @returns its directory, undefined for a file of another package
+     */
+    addonPackageOf(file: string): string | undefined;
+    /**
+     * The native files of a directory of a package holding addons: the files node loads at run time (its addons, its
+     * libraries, its manifest, its data), without its scripts (bundled) and what node never loads
+     * @param root the directory of the package
+     * @param directory
+     */
+    nativeFilesOf(root: string, directory: string): string[];
+    /**
+     * The addons of the packages sharing the framework bundled with the application which are not shipped: none of
+     * their addons is loaded by a require or a path the bundler follows (they would not be found at run time)
+     * @param inputs the files bundled
+     * @param shipped the files of the tree (the addons loaded by a require, the files read by a path from a module)
+     * @returns the warnings, one by package
+     */
+    unshippedAddons(inputs: Iterable<string>, shipped: Iterable<string>): string[];
     /**
      * Resolve an import as esbuild does
      * @param build

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
   "keywords": [
     "lakutata",