@lakutata/builder 3.0.0-beta.5 → 3.0.0

package/dist/esm/lib/Native.js

@@ -11,6 +11,16 @@ import { gzipSync } from 'node:zlib';
 function contentOf(file) {
     return file.content ?? readFileSync(file.source);
 }
+/**
+ * Whether a package is the framework, or built on it (it depends on it)
+ * @param manifest
+ */
+function sharesFramework(manifest) {
+    const name = String(manifest.name ?? '');
+    if (name === 'lakutata' || name.startsWith('@lakutata/'))
+        return true;
+    return ['dependencies', 'peerDependencies', 'optionalDependencies'].some((field) => !!manifest[field] && ('lakutata' in manifest[field] || '@lakutata/core' in manifest[field]));
+}
 /**
  * The shared libraries: the addons, and the libraries they are linked with (sharp and libvips)
  */
@@ -221,7 +231,13 @@ export class NativeCollector {
         const info = this.package(root);
         if (!info)
             return false;
-        return info.addons || this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
+        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
+        if (sharesFramework(info.manifest))
+            return false;
+        return this.dependencies(root).some(({ root: dependency }) => !!this.package(dependency)?.addons);
     }
     /**
      * Resolve an import as esbuild does
@@ -232,6 +248,18 @@ export class NativeCollector {
         const result = await build.resolve(args.path, { kind: args.kind, resolveDir: args.resolveDir, importer: args.importer, pluginData: { [RESOLVING]: true } });
         return result.errors.length || result.external || !result.path ? undefined : realpathSync(result.path);
     }
+    /**
+     * Whether a package is an optional dependency of the package of a module: an optional peer dependency
+     * (peerDependenciesMeta) or an optional dependency
+     * @param specifier
+     * @param importer
+     */
+    isOptionalOf(specifier, importer) {
+        const name = specifierPackage(specifier);
+        const root = name && importer ? this.packageRoot(existsSync(importer) ? realpathSync(importer) : importer) : undefined;
+        const manifest = root ? this.package(root)?.manifest : undefined;
+        return !!name && !!manifest && (!!manifest.peerDependenciesMeta?.[name]?.optional || !!manifest.optionalDependencies?.[name]);
+    }
     /**
      * The plugin of the bundle: the native packages are external, the addons of the application are loaded from the tree
      * @param transforms the transformations of the sources of the modules (the paths of the workers), giving their new
@@ -245,8 +273,10 @@ export class NativeCollector {
                     if (args.pluginData?.[RESOLVING] || isBuiltin(args.path) || args.kind === 'entry-point')
                         return undefined;
                     const file = await this.resolve(build, args);
+                    //An optional dependency of the package importing it, not installed: left out, it throws when it is
+                    //loaded at run time, as without the bundle (the drivers of the stores the application does not use)
                     if (!file)
-                        return undefined;
+                        return this.isOptionalOf(args.path, args.importer) ? { path: args.path, external: true } : undefined;
                     const root = this.packageRoot(file);
                     if (this.isNative(root)) {
                         const name = specifierPackage(args.path);

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

@@ -136,6 +136,13 @@ export declare class NativeCollector {
         resolveDir: string;
         importer: string;
     }): Promise<string | undefined>;
+    /**
+     * Whether a package is an optional dependency of the package of a module: an optional peer dependency
+     * (peerDependenciesMeta) or an optional dependency
+     * @param specifier
+     * @param importer
+     */
+    protected isOptionalOf(specifier: string, importer: string): boolean;
     /**
      * The plugin of the bundle: the native packages are external, the addons of the application are loaded from the tree
      * @param transforms the transformations of the sources of the modules (the paths of the workers), giving their new

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakutata/builder",
-  "version": "3.0.0-beta.5",
+  "version": "3.0.0",
   "description": "The builder of the applications of the lakutata framework: their bundles, their executables (Node.js, Bun) with their native addons and their resources.",
   "type": "module",
   "main": "./dist/esm/index.js",