npm-pkgbuild 10.18.1 → 10.19.0

package/README.md

@@ -125,7 +125,7 @@ see [mf-hosting](https://www.npmjs.com/package/mf-hosting) module as an example.
     *   [tmpdir](#tmpdir)
     *   [execute](#execute)
         *   [Parameters](#parameters-10)
-*   [available](#available)
+*   [prepare](#prepare)
 
 ## ContentProvider
 
@@ -317,7 +317,7 @@ Execute package generation
 *   `options`  
 *   `expander`  
 
-## available
+## prepare
 
 Check for rpmbuild presence.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "10.18.1",
+  "version": "10.19.0",
   "publishConfig": {
     "access": "public"
   },
@@ -40,10 +40,10 @@
     "lint:docs": "documentation lint ./src/**/*.mjs"
   },
   "dependencies": {
-    "@npmcli/arborist": "^6.1.5",
+    "@npmcli/arborist": "^6.1.6",
     "@vercel/nft": "^0.22.5",
     "aggregate-async-iterator": "^1.1.15",
-    "commander": "^9.4.1",
+    "commander": "^9.5.0",
     "content-entry": "^5.2.16",
     "content-entry-filesystem": "^5.2.13",
     "content-entry-transform": "^1.4.27",
@@ -64,7 +64,7 @@
     "ava": "^5.1.0",
     "c8": "^7.12.0",
     "documentation": "^14.0.1",
-    "semantic-release": "^19.0.5",
+    "semantic-release": "^20.0.2",
     "stream-buffers": "^3.0.2"
   },
   "engines": {
@@ -72,7 +72,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/arlac77/npm-pkgbuild.git"
+    "url": "https://github.com/arlac77/npm-pkgbuild"
   },
   "bugs": {
     "url": "https://github.com/arlac77/npm-pkgbuild/issues"

package/src/extract-from-package.mjs

@@ -1,5 +1,4 @@
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { packageDirectory } from "pkg-dir";
 import { packageWalker } from "npm-package-walker";
 import { createContext } from "expression-expander";
@@ -44,55 +43,6 @@ export const npmArchMapping = {
   ppc64: "ppc64"
 };
 
-/**
- * Deliver basic properties from the root package.
- * @param {Object} content of root package.json
- * @returns {Object} key value pairs extracted from package
- */
-function extractFromRootPackage(json) {
-  const properties = Object.fromEntries(
-    ["name", "version", "description", "homepage", "license"]
-      .map(key => [key, json[key]])
-      .filter(([k, v]) => v !== undefined)
-  );
-
-  if (properties.name) {
-    properties.name = properties.name.replace(/^\@[^\/]+\//, "");
-  }
-
-  if (json.bugs?.url) {
-    properties.bugs = json.bugs.url;
-  }
-
-  properties.access = json.publishConfig
-    ? json.publishConfig.access
-    : "private";
-
-  Object.assign(properties, json.config);
-
-  if (json.contributors) {
-    properties.maintainer = json.contributors.map(
-      c => `${c.name} <${c.email}>`
-    )[0];
-  }
-
-  if (json.repository) {
-    if (typeof json.repository === "string") {
-      properties.source = json.repository;
-    } else {
-      if (json.repository.url) {
-        properties.source = json.repository.url;
-      }
-    }
-  }
-
-  return {
-    properties,
-    dependencies: { ...json.engines },
-    context: createContext({ properties })
-  };
-}
-
 const entryAttributeNames = ["owner", "group", "mode"];
 
 /**
@@ -137,7 +87,8 @@ function* content2Sources(content, dir) {
  * @property {ContentProvider[]} sources content providers
  * @property {Object} dependencies
  * @property {Object} output package type
- * @property {string} variant identifier of the variant
+ * @property {Object} variant identifier of the variant
+ * @property {string} variant.name name of the variant
  */
 
 /**
@@ -145,106 +96,183 @@ function* content2Sources(content, dir) {
  * - for each architecture deliver a new result
  * - if no architecture is given one result set is provided nethertheless
  * - architectures are taken from cpu (node arch ids) and from pkgbuild.arch (raw arch ids)
- * - architecture given in a abstract definition are used to restrict the set of avaliable architectures
+ * - architecture given in a variant definition are used to restrict the set of avaliable architectures
  * @param {Object} options
- * @param {Object} options.json package.json content
  * @param {string} options.dir where to look for package.json
+ * @param {Object} env as delared in process.env
  * @returns {AsyncIterator<PackageDefinition>}
  */
 export async function* extractFromPackage(options = {}, env = {}) {
-  let variant = "default";
-  let sources = [];
-  let output = {};
-  let arch = new Set();
-  let restrictArch = new Set();
-  let groups;
-
-  function processPkg(json, dir, modulePath) {
-    const pkgbuild = json.pkgbuild;
-
-    if (pkgbuild) {
-      if(pkgbuild?.requires?.environment) {
-        if(env[pkgbuild.requires.environment.has] === undefined) {
+  const variants = {};
+  const fragments = {};
+  let root, parent;
+
+  await packageWalker(async (packageContent, base, modulePath) => {
+    let i = 0;
+    for (const pkgbuild of Array.isArray(packageContent.pkgbuild)
+      ? packageContent.pkgbuild
+      : packageContent.pkgbuild
+      ? [packageContent.pkgbuild]
+      : []) {
+      if (pkgbuild.requires?.environment) {
+        if (env[pkgbuild.requires.environment.has] === undefined) {
           return;
         }
       }
 
-      if (modulePath) {
-        if (!pkgbuild.abstract) {
-          if (pkgbuild.groups === groups) {
-            dependencies[pkgbuild.name || json.name] = ">=" + json.version;
-          }
-        }
-      } else {
-        groups = pkgbuild.groups;
+      const fragment = {
+        name: `${packageContent.name}[${i++}]`,
+        depends: packageContent.engines || {},
+        arch: new Set(),
+        restrictArch: new Set()
+      };
 
-        if (json.cpu) {
-          for (const a of asArray(json.cpu)) {
-            arch.add(npmArchMapping[a]);
-          }
+      if (packageContent.cpu) {
+        for (const a of asArray(packageContent.cpu)) {
+          fragment.arch.add(npmArchMapping[a]);
         }
-        if (pkgbuild.arch) {
-          for (const a of asArray(pkgbuild.arch)) {
-            arch.add(a);
+      }
+      if (pkgbuild.arch) {
+        for (const a of asArray(pkgbuild.arch)) {
+          fragment.arch.add(a);
+          if (modulePath.length === 0) {
+            fragment.restrictArch.add(a);
           }
         }
+        delete pkgbuild.arch;
+      }
+
+      if(pkgbuild.hooks) {
+        pkgbuild.hooks = resolve(base, pkgbuild.hooks);
+      }
+
+      for (const k of ["output", "content", "depends"]) {
+        if (pkgbuild[k]) {
+          fragment[k] = pkgbuild[k];
+          delete pkgbuild[k];
+        }
       }
 
-      if (pkgbuild.abstract || !modulePath) {
-        if (pkgbuild.variant) {
-          variant = pkgbuild.variant;
+      const properties = Object.assign(
+        {
+          access: packageContent.publishConfig?.access || "private"
+        },
+        packageContent.config,
+        modulePath.length === 0 &&
+        Object.fromEntries(
+          ["name", "version", "description", "homepage", "license"]
+            .map(key => [key, packageContent[key]])
+            .filter(([k, v]) => v !== undefined)
+        ),
+        pkgbuild,
+      );
+
+      if (modulePath.length >= 1) {
+        fragment.parent =
+          modulePath.length === 1 ? parent : modulePath[modulePath.length - 2];
+      } else {
+        if (properties.name) {
+          properties.name = properties.name.replace(/^\@[^\/]+\//, "");
+        }
+
+        if (packageContent.bugs?.url) {
+          properties.bugs = packageContent.bugs.url;
+        }
+
+        if (packageContent.contributors) {
+          properties.maintainer = packageContent.contributors.map(
+            c => `${c.name} <${c.email}>`
+          )[0];
         }
 
-        if (pkgbuild.arch) {
-          for (const a of asArray(pkgbuild.arch)) {
-            restrictArch.add(a);
+        if (typeof packageContent.repository === "string") {
+          properties.source = packageContent.repository;
+        } else {
+          if (packageContent.repository?.url) {
+            properties.source = packageContent.repository.url;
           }
         }
+      }
 
-        Object.assign(output, pkgbuild.output);
+      fragment.properties = properties;
+      fragment.dir = join(base, ...modulePath.map(p => `node_modules/${p}`));
 
-        Object.entries(pkgbuild)
-          .filter(([k, v]) => typeof v === "string")
-          .forEach(([k, v]) => (properties[k] = v));
+      fragments[packageContent.name] = fragment;
+
+      if (pkgbuild.variant) {
+        fragment.priority = 1;
+        variants[pkgbuild.variant] = fragment;
+      }
 
-        sources.push(...content2Sources(context.expand(pkgbuild.content), dir));
+      if (modulePath.length === 0) {
+        root = fragment;
       }
-      Object.assign(dependencies, pkgbuild.depends);
     }
+    parent = packageContent.name;
+
+    return true;
+  }, await packageDirectory({ cwd: options.dir }));
+
+  if (root && Object.keys(variants).length === 0) {
+    variants.default = root;
   }
 
-  let json = options.json;
-  let dir = options.dir;
+  //console.log(variants);
 
-  if (!json) {
-    dir = await packageDirectory({ cwd: dir });
+  for (const [name, variant] of Object.entries(variants)) {
+    const arch = [...variant.arch].sort();
+    const properties = {};
+    const depends = {};
+    const output = {};
+    const sources = [];
 
-    json = JSON.parse(
-      await readFile(join(dir, "package.json"), utf8StreamOptions)
-    );
-  }
+    for (
+      let fragment = variant;
+      fragment;
+      fragment = fragments[fragment.parent]
+    ) {
+      const context = createContext({ properties: fragment.properties });
 
-  const { properties, dependencies, context } = extractFromRootPackage(json);
+      Object.assign(properties, fragment.properties);
+      Object.assign(depends, fragment.depends);
+      Object.assign(output, fragment.output);
 
-  await packageWalker(async (packageContent, base, modulePath) => {
-    if (modulePath.length > 0) {
-      processPkg(packageContent, base, modulePath);
+      sources.push(
+        ...content2Sources(context.expand(fragment.content), fragment.dir)
+      );
     }
-    return true;
-  }, dir);
 
-  processPkg(json, dir);
+    properties.variant = name;
 
-  properties.variant = variant;
+    const context = createContext({ properties });
+
+    const result = {
+      context,
+      variant: { name },
+      sources,
+      output,
+      dependencies: depends,
+      properties: context.expand(properties)
+      };
 
-  if (arch.size > 0) {
-    // provide each arch separadly
+    if(arch.length === 0) {
+      yield result;
+    }
+    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) {
+        if (!options.prepare || npmArchMapping[process.arch] === a) {
           numberOfArchs++;
           properties.arch = [a];
           yield {
@@ -265,15 +293,5 @@ export async function* extractFromPackage(options = {}, env = {}) {
         }`
       );
     }
-  } else {
-    // or one set if no arch is given
-    yield {
-      properties: context.expand(properties),
-      sources,
-      dependencies,
-      output,
-      variant: { name: variant, type: Object.keys(output) },
-      context
-    };
-  }
+  */
 }