npm-pkgbuild 7.11.4 → 7.11.8

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2021 by arlac77
+Copyright (c) 2018-2022 by arlac77
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

package/README.md

@@ -11,14 +11,14 @@
 
 ## npm-pkgbuild
 
-create ArchLinux, RPM and debian packages from npm packages.
+create ArchLinux, RPM and Debian packages from npm packages.
 
 # usage
 
 In a package directory execute
 
 ```shell
-npm-pkgbuild --npm-dist --npm-modules pkgbuild pacman makepkg
+npm-pkgbuild --pkg
 ```
 
 This will create a PKGBUILD file and execute it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "npm-pkgbuild",
-  "version": "7.11.4",
+  "version": "7.11.8",
   "publishConfig": {
     "access": "public"
   },
@@ -8,7 +8,7 @@
   "exports": {
     ".": "./src/module.mjs"
   },
-  "description": "create ArchLinux, RPM and debian packages from npm packages",
+  "description": "create ArchLinux, RPM and Debian packages from npm packages",
   "keywords": [
     "ArchLinux",
     "arch-linux",

package/src/module.mjs

@@ -6,5 +6,5 @@ export * from "./content/node-modules-content-provider.mjs";
 export * from "./content/npm-pack-content-provider.mjs";
 export * from "./output/deb.mjs";
 export * from "./output/rpm.mjs";
-export * from "./output/pkg.mjs";
+export * from "./output/arch.mjs";
 export * from "./output/packager.mjs";

package/src/npm-pkgbuild-cli.mjs

@@ -8,7 +8,7 @@ import { aggregateFifo } from "aggregate-async-iterator";
 import { createContext } from "expression-expander";
 import { packageDirectory } from "pkg-dir";
 import { utf8StreamOptions, extractFromPackage } from "./util.mjs";
-import { FileContentProvider, DEB, PKG, RPM } from "npm-pkgbuild";
+import { FileContentProvider, DEB, ARCH, RPM } from "npm-pkgbuild";
 import { createExpressionTransformer } from "./util.mjs";
 
 const { version, description } = JSON.parse(
@@ -18,7 +18,7 @@ const { version, description } = JSON.parse(
 
 const cwd = process.cwd();
 
-const allOutputs = [DEB, PKG, RPM];
+const allOutputs = [DEB, ARCH, RPM];
 
 program.description(description).version(version);
 
@@ -27,12 +27,16 @@ allOutputs.forEach(o =>
 );
 
 program
+  .option("--verbose", "be more verbose", false)
   .option("-D --define <a=b>", "define property", str => {
     const kv = str.split(/=/);
     return Object.fromEntries([kv]);
   })
-  .option("-d --destination <dir>", "where to put the package(s)", cwd)
-  .option("--verbose", "be more verbose", false)
+  .option(
+    "-d --destination <dir>",
+    "where to put the package(s)",
+    join(cwd, "dist")
+  )
   .option("-p --pkgdir <dir>", "which package to use", process.cwd())
   .option(
     "-c --content <dir>",
@@ -48,18 +52,19 @@ program
   )
   .action(async options => {
     try {
-      const pkgDir = await packageDirectory({ cwd: options.pkgdir});
+      const pkgDir = await packageDirectory({ cwd: options.pkgdir });
 
       if (options.verbose) {
         console.log(`pkgdir: ${pkgDir}`);
       }
 
-      const { properties, sources, output } = await extractFromPackage(
-        JSON.parse(
-          await readFile(join(pkgDir, "package.json"), utf8StreamOptions)
-        ),
-        pkgDir
-      );
+      const { properties, sources, output, dependencies } =
+        await extractFromPackage(
+          JSON.parse(
+            await readFile(join(pkgDir, "package.json"), utf8StreamOptions)
+          ),
+          pkgDir
+        );
 
       for (const outputFactory of allOutputs.filter(
         o => options[o.name] === true || output[o.name] !== undefined
@@ -80,7 +85,7 @@ program
         const context = createContext({ properties });
         const output = new outputFactory(properties);
         const transformer = [createExpressionTransformer(properties)];
- 
+
         if (options.verbose) {
           console.log(output.properties);
         }
@@ -88,11 +93,21 @@ program
         const fileName = await output.execute(
           aggregateFifo(sources.map(c => c[Symbol.asyncIterator]())),
           transformer,
+          dependencies,
           options,
           path => context.expand(path)
         );
 
-        //console.log(`#<CI>publish ${fileName}`);
+        /*
+        console.log(`#<CI>publish ${fileName}`);
+
+        if (publish !== undefined) {
+          context.properties.arch = arch;
+      
+          publish = publish.replace(/\{\{(\w+)\}\}/m, (match, key, offset, string) =>
+            context.evaluate(key)
+          );
+      */
       }
     } catch (e) {
       console.log(e);

package/src/output/{pkg.mjs → arch.mjs}

@@ -1,14 +1,17 @@
-import { join } from "path";
-import { cp } from "fs/promises";
+import { join, dirname } from "path";
+import { createReadStream, createWriteStream } from "fs";
+import { mkdir } from "fs/promises";
+import { pipeline } from "stream/promises";
 import { execa } from "execa";
 import { EmptyContentEntry, ReadableStreamContentEntry } from "content-entry";
+import { iterableStringInterceptor } from "iterable-string-interceptor";
 import {
   keyValueTransformer,
   equalSeparatedKeyValuePairOptions
 } from "key-value-transformer";
 import { Packager } from "./packager.mjs";
 import { copyEntries, transform, fieldProvider } from "../util.mjs";
-import { quote } from "../util.mjs";
+import { quote, utf8StreamOptions } from "../util.mjs";
 
 /**
  * @type KeyValueTransformOptions
@@ -31,9 +34,9 @@ export const pkgKeyValuePairOptions = {
     }${lineEnding}`
 };
 
-export class PKG extends Packager {
+export class ARCH extends Packager {
   static get name() {
-    return "pkg";
+    return "arch";
   }
 
   static get fileNameExtension() {
@@ -49,20 +52,21 @@ export class PKG extends Packager {
     return `${p.name}-${p.version}-${p.release}-${p.arch}${this.constructor.fileNameExtension}`;
   }
 
-  async execute(sources, transformer, options, expander) {
+  async execute(sources, transformer, dependencies, options, expander) {
     const properties = this.properties;
 
-    if(properties.source) {
+    if (properties.source) {
       properties.md5sums = ["SKIP"];
     }
 
-    //properties.depends = makeDepends({ ...pkg.engines });
+    //properties.depends = makeDepends(dependencies);
 
     const staging = await this.tmpdir;
 
     async function* trailingLines() {
       yield `
 package() {
+  depends=(${makeDepends(dependencies).map(v=>quote(v)).join(',')})
   cp -r $srcdir/* "$pkgdir"
 }
 `;
@@ -90,12 +94,24 @@ package() {
     });
 
     if (properties.hooks) {
-      await cp(
-        join(options.pkgdir, properties.hooks),
-        join(staging, properties.hooks),
-        {
-          preserveTimestamps: true
-        }
+      async function* transformer(expression, remainder, source, cb) {
+        const value = properties[expression];
+        yield value === undefined ? "" : value;
+      }
+
+      const destination = join(staging, properties.hooks);
+
+      await mkdir(dirname(destination), { recursive: true });
+
+      await pipeline(
+        iterableStringInterceptor(
+          createReadStream(
+            join(options.pkgdir, properties.hooks),
+            utf8StreamOptions
+          ),
+          transformer
+        ),
+        createWriteStream(destination, utf8StreamOptions)
       );
     }
 
@@ -105,7 +121,7 @@ package() {
       console.log(`stagingDir: ${staging}`);
     }
 
-    const makepkg = await execa("makepkg", ["-f"], {
+    const makepkg = await execa("makepkg", ["-f", "-e"], {
       cwd: staging,
       env: { PKGDEST: options.destination }
     });
@@ -125,7 +141,7 @@ package() {
 const fields = {
   pkgname: { alias: "name", type: "string[]", mandatory: true },
   pkgver: { alias: "version", type: "string", mandatory: true },
-  pkgrel: { alias: "release", type: "integer", default: 0, mandatory: true },
+  pkgrel: { alias: "release", type: "integer", default: 1, mandatory: true },
   epoch: { type: "integer", default: 0 },
   pkgdesc: { alias: "description", type: "string", mandatory: true },
   url: { alias: "homepage", type: "string" },
@@ -154,34 +170,21 @@ const fields = {
   options: { type: "string[]" }
 };
 
-/*
-  out.write(
-    `# ${pkg.contributors
-      .map(
-        (c, i) => `${i ? "Contributor" : "Maintainer"}: ${c.name} <${c.email}>`
-      )
-      .join("\n# ")}
-
-      build() {
-  cd \${pkgname}${directory}
-  sed -i 's/"version": ".* /"version": "${
-    context.properties.pkgver
-  }",/' package.json
-  npm install
-  npm pack
-  npm prune --production
-}
+const mapping = {
+  node: "nodejs"
+};
 
-package() {
-  depends=(${makeDepends(pkg.pacman.depends)
-    .map(a => `"${a}"`)
-    .join(" ")})
+function normalizeExpression(e) {
+  e = e.replace(/\-([\w\d]+)$/, "");
+  if (e.match(/^\d+/)) {
+    return `>=${e}`;
+  }
 
-  mkdir -p \${pkgdir}${installdir}
-  npx npm-pkgbuild --package \${srcdir}/\${pkgname}${directory} --staging \${pkgdir} content
+  return e;
 }
-*/
 
-const mapping = {
-  node: "nodejs"
-};
+function makeDepends(dependencies) {
+  return Object.entries(dependencies).map(
+    ([name, version]) => `${name}${normalizeExpression(version)}`
+  );
+}

package/src/output/deb.mjs

@@ -23,7 +23,7 @@ export class DEB extends Packager {
     return `${p.name}_${p.version}_${p.arch}${this.constructor.fileNameExtension}`;
   }
 
-  async execute(sources, transformer, options, expander) {
+  async execute(sources, transformer, dependencies, options, expander) {
     const properties = this.properties;
     const staging = await this.tmpdir;
 

package/src/output/packager.mjs

@@ -54,5 +54,5 @@ export class Packager {
   /**
    * Execute package generation
    */
-  async execute(sources, options) {}
+  async execute(sources, transformer, dependencies, options, expander) {}
 }

package/src/output/rpm.mjs

@@ -27,7 +27,7 @@ export class RPM extends Packager {
     return fields;
   }
 
-  async execute(sources, transformer, options, expander) {
+  async execute(sources, transformer, dependencies, options, expander) {
     const properties = this.properties;
     const tmp = await this.tmpdir;
 

package/src/util.mjs

@@ -99,8 +99,8 @@ export async function extractFromPackage(pkg, dir) {
   let output = {};
 
   const processPkg = pkg => {
-    if (pkg.pkgbuild) {
-      const pkgbuild = pkg.pkgbuild;
+    if (pkg.pkg) {
+      const pkgbuild = pkg.pkg;
 
       Object.assign(output, pkgbuild.output);