npm-pkgbuild 7.13.0 → 7.14.0

package/package.json

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

package/src/content/npm-pack-content-provider.mjs

@@ -16,18 +16,21 @@ export class NPMPackContentProvider extends ContentProvider {
     return "npm-pack";
   }
 
-  static get description()
-  {
+  static get description() {
     return "use npm pack as source";
   }
 
+  constructor(definitions) {
+    super();
+    Object.assign(this, definitions);
+  }
+
   async *[Symbol.asyncIterator]() {
-    //const m = await pacote.manifest(context.dir);
-    //console.log('got it', m);
+    console.log("pacote", this.dir);
 
     const entries = [];
 
-    await pacote.tarball.stream(context.dir, async stream => {
+    await pacote.tarball.stream(this.dir, async stream => {
       const extract = tar.extract();
 
       extract.on("entry", async (header, stream, next) => {

package/src/extract-from-package.mjs

@@ -0,0 +1,98 @@
+import { packageWalker } from "npm-package-walker";
+import { asArray } from "./util.mjs";
+import { NPMPackContentProvider } from "./content/npm-pack-content-provider.mjs";
+import { NodeModulesContentProvider } from "./content/node-modules-content-provider.mjs";
+import { FileContentProvider } from "./content/file-content-provider.mjs";
+import { DEB } from "./output/deb.mjs";
+import { ARCH } from "./output/arch.mjs";
+import { RPM } from "./output/rpm.mjs";
+
+export const allInputs = [NPMPackContentProvider, NodeModulesContentProvider];
+export const allOutputs = [DEB, ARCH, RPM];
+
+/**
+ * Extract package definition from package.json.
+ * @param {Object} pkg package.json content
+ * @param {string} dir
+ * @returns {Object}
+ */
+export async function extractFromPackage(pkg, dir) {
+  const properties = Object.fromEntries(
+    ["name", "version", "description", "homepage", "license"]
+      .map(key => [key, pkg[key]])
+      .filter(([k, v]) => v !== undefined)
+  );
+
+  if (pkg.bugs) {
+    if (pkg.bugs.url) {
+      properties.bugs = pkg.bugs.url;
+    }
+  }
+
+  Object.assign(properties, pkg.config);
+
+  if (properties.name) {
+    properties.name = properties.name.replace(/^\@\w+\//, "");
+  }
+
+  if (pkg.contributors) {
+    properties.maintainer = pkg.contributors.map(
+      c => `${c.name} <${c.email}>`
+    )[0];
+  }
+
+  if (pkg.repository) {
+    if (pkg.repository.url) {
+      properties.source = pkg.repository.url;
+    }
+  }
+
+  let dependencies = { ...pkg.engines };
+  let sources = [];
+  let output = {};
+
+  const processPkg = (pkg,dir) => {
+    if (pkg.pkg) {
+      const pkgbuild = pkg.pkg;
+
+      Object.assign(output, pkgbuild.output);
+
+      Object.entries(pkgbuild)
+        .filter(([k, v]) => typeof v === "string")
+        .forEach(([k, v]) => (properties[k] = v));
+
+      if (pkgbuild.content) {
+        Object.entries(pkgbuild.content).forEach(
+          ([destination, definitions]) => {
+            for (const definition of asArray(definitions)) {
+                if(definition.type) {
+                    const type = allInputs.find(i => i.name === definition.type);
+                    if(type) {
+                        delete definition.type;
+                        sources.push(new type({ ...definition, dir}, { destination }));
+                    }
+                    else {
+                        console.error("Unknown type '${type}'");
+                    }
+                }
+                else {
+                    sources.push(new FileContentProvider(definition, { destination }));
+                }
+            }
+          }
+        );
+      }
+
+      Object.assign(dependencies, pkgbuild.depends);
+    }
+  };
+
+  await packageWalker(async (pkg, base, modulePath) => {
+    processPkg(pkg,base);
+    return true;
+  }, dir);
+
+  processPkg(pkg, dir);
+
+  return { properties, sources, dependencies, output };
+}

package/src/module.mjs

@@ -1,5 +1,6 @@
 
 export * from "./util.mjs";
+export * from "./extract-from-package.mjs";
 export * from "./content/content-provider.mjs";
 export * from "./content/file-content-provider.mjs";
 export * from "./content/node-modules-content-provider.mjs";
@@ -7,4 +8,4 @@ export * from "./content/npm-pack-content-provider.mjs";
 export * from "./output/deb.mjs";
 export * from "./output/rpm.mjs";
 export * from "./output/arch.mjs";
-export * from "./output/packager.mjs";
+export * from "./output/packager.mjs";

package/src/npm-pkgbuild-cli.mjs

@@ -9,16 +9,13 @@ import { createContext } from "expression-expander";
 import { packageDirectory } from "pkg-dir";
 import {
   utf8StreamOptions,
-  extractFromPackage,
   createExpressionTransformer
 } from "./util.mjs";
 import {
   FileContentProvider,
-  DEB,
-  ARCH,
-  RPM,
-  NPMPackContentProvider,
-  NodeModulesContentProvider
+  allInputs,
+  allOutputs,
+  extractFromPackage
 } from "npm-pkgbuild";
 
 const { version, description } = JSON.parse(
@@ -28,13 +25,9 @@ const { version, description } = JSON.parse(
 
 const cwd = process.cwd();
 
-const allInputs = [NPMPackContentProvider, NodeModulesContentProvider];
-const allOutputs = [DEB, ARCH, RPM];
-
 program.description(description).version(version);
 
 allOutputs.forEach(o => program.option(`--${o.name}`, o.description));
-
 allInputs.forEach(i => program.option(`--${i.name}`, i.description));
 
 program

package/src/util.mjs

@@ -4,8 +4,6 @@ import { pipeline } from "stream/promises";
 import { createWriteStream } from "fs";
 import { iterableStringInterceptor } from "iterable-string-interceptor";
 import { ReadableStreamContentEntry } from "content-entry";
-import { FileContentProvider } from "npm-pkgbuild";
-import { packageWalker } from "npm-package-walker";
 
 export const utf8StreamOptions = { encoding: "utf8" };
 
@@ -60,80 +58,6 @@ export function fieldProvider(properties, fields) {
   };
 }
 
-/**
- * Extract package definition from package.json.
- * @param {Object} pkg package.json content
- * @param {string} dir
- * @returns {Object}
- */
-export async function extractFromPackage(pkg, dir) {
-  const properties = Object.fromEntries(
-    ["name", "version", "description", "homepage", "license"]
-      .map(key => [key, pkg[key]])
-      .filter(([k, v]) => v !== undefined)
-  );
-
-  if (pkg.bugs) {
-    if (pkg.bugs.url) {
-      properties.bugs = pkg.bugs.url;
-    }
-  }
-
-  Object.assign(properties, pkg.config);
-
-  if (properties.name) {
-    properties.name = properties.name.replace(/^\@\w+\//, "");
-  }
-
-  if (pkg.contributors) {
-    properties.maintainer = pkg.contributors.map(
-      c => `${c.name} <${c.email}>`
-    )[0];
-  }
-
-  if (pkg.repository) {
-    if (pkg.repository.url) {
-      properties.source = pkg.repository.url;
-    }
-  }
-
-  let dependencies = { ...pkg.engines };
-  let sources = [];
-  let output = {};
-
-  const processPkg = pkg => {
-    if (pkg.pkg) {
-      const pkgbuild = pkg.pkg;
-
-      Object.assign(output, pkgbuild.output);
-
-      Object.entries(pkgbuild)
-        .filter(([k, v]) => typeof v === "string")
-        .forEach(([k, v]) => (properties[k] = v));
-
-      if (pkgbuild.content) {
-        Object.entries(pkgbuild.content).forEach(
-          ([destination, definitions]) => {
-            for (const d of asArray(definitions)) {
-              sources.push(new FileContentProvider(d, { destination }));
-            }
-          }
-        );
-      }
-
-      Object.assign(dependencies, pkgbuild.depends);
-    }
-  };
-
-  await packageWalker(async (pkg, base, modulePath) => {
-    processPkg(pkg);
-    return true;
-  }, dir);
-
-  processPkg(pkg);
-
-  return { properties, sources, dependencies, output };
-}
 
 export function createModeTransformer(mode, match) {
   return {