npm-pkgbuild 10.7.1 → 10.7.2

package/package.json

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

package/src/extract-from-package.mjs

@@ -31,47 +31,21 @@ export const npmArchMapping = {
   ppc64: "ppc64"
 };
 
-const entryAttributeNames = ["owner", "group", "mode"];
-
 /**
- * @typedef {Object} PackageDefinition
- * @property {Object} properties values describing the package attributes
- * @property {ContentProvider[]} sources content providers
- * @property {Object} dependencies
- * @property {Object} output package type
- * @property {string} variant identifier of the variant
+ * Deliver basic properties from the root package
+ * @param {Object} json  content of rool package.json
+ * @returns {Object} key value pairs extracted from json
  */
-
-/**
- * Extract package definition from package.json.
- * - for each architecture deliver a new result
- * - if not 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 reduce the set of avaliable architectures
- * @param {Object} options
- * @param {Object} options.json package.json content
- * @param {string} options.pkgDir
- * @returns {AsyncIter<PackageDefinition>}
- */
-export async function* extractFromPackage(options = {}) {
-  let json = options.json;
-  let dir = options.pkgDir;
-
-  if (!json) {
-    dir = await packageDirectory({ cwd: dir });
-
-    json = JSON.parse(
-      await readFile(join(dir, "package.json"), utf8StreamOptions)
-    );
-  }
-
+function extractFromRootPackage(json) {
   const properties = Object.fromEntries(
     ["name", "version", "description", "homepage", "license"]
       .map(key => [key, json[key]])
       .filter(([k, v]) => v !== undefined)
   );
 
-  let variant = "default";
+  if (properties.name) {
+    properties.name = properties.name.replace(/^\@\w+\//, "");
+  }
 
   if (json.bugs) {
     if (json.bugs.url) {
@@ -79,16 +53,11 @@ export async function* extractFromPackage(options = {}) {
     }
   }
 
-  Object.assign(properties, json.config);
-
-  if (properties.name) {
-    properties.name = properties.name.replace(/^\@\w+\//, "");
-  }
+  properties.access = json.publishConfig
+    ? json.publishConfig.access
+    : "private";
 
-  properties.access = "private";
-  if (json.publishConfig) {
-    properties.access = json.publishConfig.access;
-  }
+  Object.assign(properties, json.config);
 
   if (json.contributors) {
     properties.maintainer = json.contributors.map(
@@ -106,92 +75,138 @@ export async function* extractFromPackage(options = {}) {
     }
   }
 
-  const context = createContext({ properties });
+  return {
+    properties,
+    dependencies: { ...json.engines },
+    context: createContext({ properties })
+  };
+}
+
+const entryAttributeNames = ["owner", "group", "mode"];
+
+/**
+ * Delivers ContetProviders from pkgbuild.content
+ * @param {Object} content from pkgbuild.content
+ * @returns {Iterator<ContentProvider>}
+ */
+function* content2Sources(content, dir) {
+  if (content) {
+    for (const [destination, definitions] of Object.entries(content)) {
+      const allEntryProperties = {};
+
+      for (const a of entryAttributeNames) {
+        if (definitions[a] !== undefined) {
+          allEntryProperties[a] = definitions[a];
+          delete definitions[a];
+        }
+      }
+
+      for (const definition of asArray(definitions)) {
+        const entryProperties = { ...allEntryProperties, destination };
+
+        if (definition.type) {
+          const type = allInputs.find(i => i.name === definition.type);
+          if (type) {
+            delete definition.type;
+            yield new type({ ...definition, dir }, entryProperties);
+          } else {
+            console.error(`Unknown type '${type}'`);
+          }
+        } else {
+          yield new FileContentProvider(definition, entryProperties);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @typedef {Object} PackageDefinition
+ * @property {Object} properties values describing the package attributes
+ * @property {ContentProvider[]} sources content providers
+ * @property {Object} dependencies
+ * @property {Object} output package type
+ * @property {string} variant identifier of the variant
+ */
 
-  let dependencies = { ...json.engines };
+/**
+ * Extract package definition from package.json.
+ * - for each architecture deliver a new result
+ * - if not 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 reduce the set of avaliable architectures
+ * @param {Object} options
+ * @param {Object} options.json package.json content
+ * @param {string} options.pkgDir
+ * @returns {AsyncIter<PackageDefinition>}
+ */
+export async function* extractFromPackage(options = {}) {
+  let variant = "default";
   let sources = [];
   let output = {};
   let arch = new Set();
   let restrictArch = new Set();
 
-  const processPkg = (json, dir, modulePath) => {
-    const pkg = json.pkgbuild;
+  function processPkg(json, dir, modulePath) {
+    const pkgbuild = json.pkgbuild;
 
-    if (pkg) {
+    if (pkgbuild) {
       if (!modulePath) {
         if (json.cpu) {
           for (const a of asArray(json.cpu)) {
             arch.add(npmArchMapping[a]);
           }
         }
-        if (pkg.arch) {
-          for (const a of asArray(pkg.arch)) {
+        if (pkgbuild.arch) {
+          for (const a of asArray(pkgbuild.arch)) {
             arch.add(a);
           }
         }
       }
 
-      if (pkg.abstract || !modulePath) {
-        if (pkg.variant) {
-          variant = pkg.variant;
+      if (pkgbuild.abstract || !modulePath) {
+        if (pkgbuild.variant) {
+          variant = pkgbuild.variant;
         }
 
-        if (pkg.arch) {
-          for (const a of asArray(pkg.arch)) {
+        if (pkgbuild.arch) {
+          for (const a of asArray(pkgbuild.arch)) {
             restrictArch.add(a);
           }
         }
 
-        Object.assign(output, pkg.output);
+        Object.assign(output, pkgbuild.output);
 
-        Object.entries(pkg)
+        Object.entries(pkgbuild)
           .filter(([k, v]) => typeof v === "string")
           .forEach(([k, v]) => (properties[k] = v));
 
-        if (pkg.content && !modulePath) {
-          Object.entries(pkg.content).forEach(([destination, definitions]) => {
-            destination = context.expand(destination);
-            definitions = context.expand(definitions);
-
-            const allEntryProperties = {};
-
-            for (const a of entryAttributeNames) {
-              if (definitions[a] !== undefined) {
-                allEntryProperties[a] = definitions[a];
-                delete definitions[a];
-              }
-            }
-
-            for (const definition of asArray(definitions)) {
-              const entryProperties = { ...allEntryProperties, destination };
-
-              if (definition.type) {
-                const type = allInputs.find(i => i.name === definition.type);
-                if (type) {
-                  delete definition.type;
-                  sources.push(
-                    new type({ ...definition, dir }, entryProperties)
-                  );
-                } else {
-                  console.error(`Unknown type '${type}'`);
-                }
-              } else {
-                sources.push(
-                  new FileContentProvider(definition, entryProperties)
-                );
-              }
-            }
-          });
-        }
+        sources.push(...content2Sources(context.expand(pkgbuild.content), dir));
       }
-      Object.assign(dependencies, pkg.depends);
+      Object.assign(dependencies, pkgbuild.depends);
     }
-  };
+  }
+
+  let json = options.json;
+  let dir = options.dir;
+
+  if (!json) {
+    dir = await packageDirectory({ cwd: dir });
+
+    json = JSON.parse(
+      await readFile(join(dir, "package.json"), utf8StreamOptions)
+    );
+  }
 
-  if (dir) {
-    await packageWalker(async (json, base, modulePath) => {
+  const { properties, dependencies, context } = extractFromRootPackage(json);
+
+  if (json) {
+  } else {
+    await packageWalker(async (packageContent, base, modulePath) => {
       if (modulePath.length > 0) {
-        processPkg(json, base, modulePath);
+        processPkg(packageContent, base, modulePath);
+      } else {
+        json = packageContent;
       }
       return true;
     }, dir);
@@ -200,7 +215,7 @@ export async function* extractFromPackage(options = {}) {
   processPkg(json, dir);
 
   properties.variant = variant;
-  
+
   if (arch.size > 0) {
     // provide each arch separadly
 
@@ -213,7 +228,14 @@ export async function* extractFromPackage(options = {}) {
         } else {
           numberOfArchs++;
           properties.arch = [a];
-          yield { properties: context.expand(properties), sources, dependencies, output, variant, context };
+          yield {
+            properties: context.expand(properties),
+            sources,
+            dependencies,
+            output,
+            variant,
+            context
+          };
         }
       }
     }
@@ -222,6 +244,13 @@ export async function* extractFromPackage(options = {}) {
     }
   } else {
     // or one set if no arch is given
-    yield { properties: context.expand(properties), sources, dependencies, output, variant, context };
+    yield {
+      properties: context.expand(properties),
+      sources,
+      dependencies,
+      output,
+      variant,
+      context
+    };
   }
 }