npm-pkgbuild 10.19.0 → 10.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "10.19.0",
+  "version": "10.19.2",
   "publishConfig": {
     "access": "public"
   },

package/src/extract-from-package.mjs

@@ -114,9 +114,26 @@ export async function* extractFromPackage(options = {}, env = {}) {
       : packageContent.pkgbuild
       ? [packageContent.pkgbuild]
       : []) {
-      if (pkgbuild.requires?.environment) {
-        if (env[pkgbuild.requires.environment.has] === undefined) {
-          return;
+      const requires = pkgbuild.requires;
+      if (requires) {
+        if (requires.properties) {
+          let fullfilled = true;
+          for (const [k, v] of Object.entries(requires.properties)) {
+            if (root.properties[k] !== v) {
+              fullfilled = false;
+              break;
+            }
+          }
+          if (!fullfilled) {
+            continue;
+          }
+          delete pkgbuild.requires;
+        }
+
+        if (requires.environment) {
+          if (env[requires.environment.has] === undefined) {
+            continue;
+          }
         }
       }
 
@@ -132,18 +149,22 @@ export async function* extractFromPackage(options = {}, env = {}) {
           fragment.arch.add(npmArchMapping[a]);
         }
       }
+
       if (pkgbuild.arch) {
         for (const a of asArray(pkgbuild.arch)) {
-          fragment.arch.add(a);
           if (modulePath.length === 0) {
+            fragment.arch.add(a);
+          } else {
             fragment.restrictArch.add(a);
           }
         }
         delete pkgbuild.arch;
       }
 
-      if(pkgbuild.hooks) {
-        pkgbuild.hooks = resolve(base, pkgbuild.hooks);
+      for (const k of ["hooks"]) {
+        if (pkgbuild[k]) {
+          pkgbuild[k] = resolve(base, pkgbuild[k]);
+        }
       }
 
       for (const k of ["output", "content", "depends"]) {
@@ -159,12 +180,12 @@ export async function* extractFromPackage(options = {}, env = {}) {
         },
         packageContent.config,
         modulePath.length === 0 &&
-        Object.fromEntries(
-          ["name", "version", "description", "homepage", "license"]
-            .map(key => [key, packageContent[key]])
-            .filter(([k, v]) => v !== undefined)
-        ),
-        pkgbuild,
+          Object.fromEntries(
+            ["name", "version", "description", "homepage", "license"]
+              .map(key => [key, packageContent[key]])
+              .filter(([k, v]) => v !== undefined)
+          ),
+        pkgbuild
       );
 
       if (modulePath.length >= 1) {
@@ -217,10 +238,8 @@ export async function* extractFromPackage(options = {}, env = {}) {
     variants.default = root;
   }
 
-  //console.log(variants);
-
   for (const [name, variant] of Object.entries(variants)) {
-    const arch = [...variant.arch].sort();
+    let arch = [...variant.arch];
     const properties = {};
     const depends = {};
     const output = {};
@@ -236,12 +255,15 @@ export async function* extractFromPackage(options = {}, env = {}) {
       Object.assign(properties, fragment.properties);
       Object.assign(depends, fragment.depends);
       Object.assign(output, fragment.output);
+      arch = new Set([...arch, ...fragment.arch]);
 
       sources.push(
         ...content2Sources(context.expand(fragment.content), fragment.dir)
       );
     }
 
+    arch = [...arch].sort();
+
     properties.variant = name;
 
     const context = createContext({ properties });
@@ -253,45 +275,20 @@ export async function* extractFromPackage(options = {}, env = {}) {
       output,
       dependencies: depends,
       properties: context.expand(properties)
-      };
+    };
 
-    if(arch.length === 0) {
+    if (arch.length === 0) {
       yield result;
-    }
-    else {
+    } else {
       for (const a of arch) {
-        result.variant.arch = a;
-        result.properties.arch = [a];
-        yield result;
-      }
-    }
-  }
-
-  /*
-    let numberOfArchs = 0;
-
-    for (const a of arch) {
-      if (!restrictArch.size || restrictArch.has(a)) {
-        if (!options.prepare || npmArchMapping[process.arch] === a) {
-          numberOfArchs++;
-          properties.arch = [a];
-          yield {
-            properties: context.expand(properties),
-            sources,
-            dependencies,
-            output,
-            variant: { name: variant, arch, type: Object.keys(output) },
-            context
-          };
+        if (variant.restrictArch.size && !variant.restrictArch.has(a)) {
+          console.log("RESTRICT", a);
+        } else {
+          result.variant.arch = a;
+          result.properties.arch = [a];
+          yield result;
         }
       }
     }
-    if (numberOfArchs === 0) {
-      console.warn(
-        `No arch remaining, ${[...arch]} : ${[...restrictArch]} : ${
-          process.arch
-        }`
-      );
-    }
-  */
+  }
 }