hugo-bin-extended 0.151.0 → 0.152.2

package/README.md

@@ -3,6 +3,7 @@
 > Binary wrapper for [Hugo](https://github.com/gohugoio/hugo)
 
 - hugo-bin-extended supports the [Extended Hugo version](https://github.com/gohugoio/hugo/releases/tag/v0.43)
+- hugo-bin-extended supports the [withdeploy Hugo version](https://github.com/gohugoio/hugo/releases/tag/v0.137.0)
 - For usage within corporate networks or behind corporate proxies, the download repository can be overwritten
 
 See [Installation options](#installation-options) for more details.
@@ -114,6 +115,7 @@ set HUGO_BIN_HUGO_VERSION=0.124.1
 - Default: `""`
 
 Set `buildTags` to `extended` to download the [extended version](https://github.com/gohugoio/hugo/releases/tag/v0.43) binary.
+Set `buildTags` to `extended,withdeploy` to download the [withdeploy version](https://github.com/gohugoio/hugo/releases/tag/v0.137.0) binary.
 
 If this is set to `extended` but it's not available for the user's platform, then the normal version will be downloaded instead.
 

package/index.js

@@ -1,7 +1,7 @@
 import process from 'node:process';
-import hugoBinExtended from './lib/index.js';
+import hugoBin from './lib/index.js';
 
-const bin = await hugoBinExtended(process.cwd());
+const bin = await hugoBin(process.cwd());
 const hugoPath = bin.path();
 
 export default hugoPath;

package/lib/index.js

@@ -13,77 +13,132 @@ const { hugoVersion: HUGO_VERSION } = JSON.parse(await fs.readFile(pkg, 'utf8'))
 const destDir = path.join(fileURLToPath(new URL('../vendor/', import.meta.url)));
 const binName = process.platform === 'win32' ? 'hugo.exe' : 'hugo';
 
+const targets = [
+  // macOS
+  { os: 'darwin', arch: 'arm64', suffix: '_darwin-universal.tar.gz' },
+  { os: 'darwin', arch: 'x64', suffix: '_darwin-universal.tar.gz' },
+
+  // Linux
+  { os: 'linux', arch: 'x64', suffix: '_linux-amd64.tar.gz' },
+  { os: 'linux', arch: 'arm64', suffix: '_linux-arm64.tar.gz' },
+  { os: 'linux', arch: 'arm', suffix: '_linux-arm.tar.gz' },
+
+  // Windows
+  { os: 'win32', arch: 'x64', suffix: '_windows-amd64.zip' },
+  { os: 'win32', arch: 'arm64', suffix: '_windows-arm64.zip' },
+
+  /* eslint-disable @stylistic/object-curly-newline */
+  // Fallbacks
+  { os: 'dragonflybsd', arch: 'x64', suffix: '_dragonfly-amd64.tar.gz', fallback: true },
+  { os: 'freebsd', arch: 'x64', suffix: '_freebsd-amd64.tar.gz', fallback: true },
+  { os: 'netbsd', arch: 'x64', suffix: '_netbsd-amd64.tar.gz', fallback: true },
+  { os: 'openbsd', arch: 'x64', suffix: '_openbsd-amd64.tar.gz', fallback: true },
+  { os: 'solaris', arch: 'x64', suffix: '_solaris-amd64.tar.gz', fallback: true }
+  /* eslint-enable @stylistic/object-curly-newline */
+];
+
 debug('[global] HUGO_VERSION:', HUGO_VERSION);
 debug('[global] destDir:', destDir);
 debug('[global] binName:', binName);
 
+/**
+ * @typedef {Object} BinOptions
+ * @property {boolean} [extended]
+ * @property {boolean} [withDeploy]
+ */
+
 /**
  * @param {string} baseUrl
  * @param {string} hugoVersion
+ * @param {BinOptions} options
+ * @returns {BinWrapper}
  */
-function extendedBin(baseUrl, hugoVersion) {
-  debug('[extendedBin] baseUrl:', baseUrl);
-  debug('[extendedBin] hugoVersion:', hugoVersion);
+function createBin(baseUrl, hugoVersion, { extended = false, withDeploy = false } = {}) {
+  debug('[createBin] %o', {
+    baseUrl,
+    hugoVersion,
+    extended,
+    withDeploy
+  });
 
   const baseName = `hugo_${hugoVersion}`;
-  const baseNameExtended = `hugo_extended_${hugoVersion}`;
-
-  return new BinWrapper()
-    .src(`${baseUrl}${baseNameExtended}_darwin-universal.tar.gz`, 'darwin', 'arm64')
-    .src(`${baseUrl}${baseNameExtended}_darwin-universal.tar.gz`, 'darwin', 'x64')
-    .src(`${baseUrl}${baseNameExtended}_linux-amd64.tar.gz`, 'linux', 'x64')
-    .src(`${baseUrl}${baseNameExtended}_linux-arm64.tar.gz`, 'linux', 'arm64')
-    .src(`${baseUrl}${baseNameExtended}_windows-amd64.zip`, 'win32', 'x64')
-    // Fall back to the normal version on unsupported platforms
-    .src(`${baseUrl}${baseName}_dragonfly-amd64.tar.gz`, 'dragonflybsd', 'x64')
-    .src(`${baseUrl}${baseName}_freebsd-amd64.tar.gz`, 'freebsd', 'x64')
-    .src(`${baseUrl}${baseName}_linux-arm.tar.gz`, 'linux', 'arm')
-    .src(`${baseUrl}${baseName}_netbsd-amd64.tar.gz`, 'netbsd', 'x64')
-    .src(`${baseUrl}${baseName}_openbsd-amd64.tar.gz`, 'openbsd', 'x64')
-    .src(`${baseUrl}${baseName}_solaris-amd64.tar.gz`, 'openbsd', 'x64')
-    .src(`${baseUrl}${baseName}_windows-arm64.zip`, 'win32', 'arm64')
-    .dest(destDir)
-    .use(binName);
+  const baseNameExtended = withDeploy ?
+    `hugo_extended_withdeploy_${hugoVersion}` :
+    `hugo_extended_${hugoVersion}`;
+  const chosenBase = extended ? baseNameExtended : baseName;
+
+  let bin = new BinWrapper();
+
+  for (const { os, arch, suffix, fallback } of targets) {
+    const name = fallback ? baseName : chosenBase;
+    bin = bin.src(`${baseUrl}${name}${suffix}`, os, arch);
+  }
+
+  return bin.dest(destDir).version(hugoVersion).use(binName);
 }
 
 /**
- * @param {import('pkg-conf').Config} config
+ * @param {import('package-config').Config} config
+ * @returns {{hugoVersion: string, downloadRepo: string, extended: boolean, withDeploy: boolean}}
  */
 function getOptions(config) {
-  const hugoVersion = [
+  const hugoVersionRaw = [
     process.env.HUGO_BIN_HUGO_VERSION,
     process.env.npm_config_hugo_bin_hugo_version,
     config.version
   ].find(Boolean) ?? HUGO_VERSION;
+
   const downloadRepo = [
     process.env.HUGO_BIN_DOWNLOAD_REPO,
     process.env.npm_config_hugo_bin_download_repo,
     config.downloadRepo
   ].find(Boolean) ?? 'https://github.com';
 
-  // Strip any leading `v` from hugoVersion because otherwise we'll end up with duplicate `v`s
-  const version = hugoVersion[0] === 'v' ? hugoVersion.slice(1) : hugoVersion;
+  const buildTags = new Set([
+    process.env.HUGO_BIN_BUILD_TAGS,
+    process.env.npm_config_hugo_bin_build_tags,
+    config.buildTags
+  ]
+    .filter(Boolean)
+    .join(',')
+    .split(',')
+    .map(s => s.trim().toLowerCase())
+    .filter(Boolean));
+
+  // const extended = buildTags.has('extended');
+  const extended = true;
+  const withDeploy = buildTags.has('withdeploy');
+
+  // Strip any leading `v` from hugoVersionRaw because otherwise we'll end up with duplicate `v`s
+  const hugoVersion = hugoVersionRaw[0] === 'v' ? hugoVersionRaw.slice(1) : hugoVersionRaw;
 
-  debug('[getOptions] hugoVersion:', version);
-  debug('[getOptions] downloadRepo:', downloadRepo);
+  debug('[getOptions] %o', {
+    hugoVersion,
+    downloadRepo,
+    extended,
+    withDeploy
+  });
 
   return {
-    hugoVersion: version,
-    downloadRepo
+    hugoVersion,
+    downloadRepo,
+    extended,
+    withDeploy
   };
 }
 
 /**
  * @param {string} cwd
+ * @returns {Promise<BinWrapper>}
  */
 async function main(cwd) {
   const config = await packageConfig('hugo-bin-extended', { cwd });
-  const { hugoVersion, downloadRepo } = getOptions(config);
+  const { hugoVersion, downloadRepo, extended, withDeploy } = getOptions(config);
   const baseUrl = `${downloadRepo}/gohugoio/hugo/releases/download/v${hugoVersion}/`;
 
   debug('[main] baseUrl:', baseUrl);
 
-  return extendedBin(baseUrl, hugoVersion);
+  return createBin(baseUrl, hugoVersion, { extended, withDeploy });
 }
 
 export default main;

package/lib/install.js

@@ -1,7 +1,7 @@
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import process from 'node:process';
-import hugoBinExtended from './index.js';
+import hugoBin from './index.js';
 
 function getProjectRoot() {
   // `projectRoot` on postinstall could be INIT_CWD introduced in npm >= 5.4
@@ -15,7 +15,7 @@ function getProjectRoot() {
   const cwd = process.cwd();
   const paths = cwd.split(path.sep);
   // If `process.cwd` ends with 'node_modules/*' then get the dependent root directory,
-  // otherwise return the `cwd` (ordinary it will be the postinstall process of hugo-bin-extended itself).
+  // otherwise return the `cwd` (ordinary it will be the postinstall process of hugo-bin itself).
   if (paths.length > 1 && paths.at(-2) === 'node_modules') {
     return path.resolve('../../', cwd);
   }
@@ -29,14 +29,14 @@ async function main() {
 
   await rm(vendorDir, { force: true, recursive: true });
 
-  const bin = await hugoBinExtended(projectRoot);
+  const bin = await hugoBin(projectRoot);
 
   try {
     await bin.run(['version']);
     console.log('Hugo binary successfully installed!');
   } catch (error) {
     console.error('Hugo binary installation failed!');
-    throw new Error(error);
+    throw new Error(error instanceof Error ? error.message : String(error));
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hugo-bin-extended",
-  "version": "0.151.0",
-  "hugoVersion": "0.151.0",
+  "version": "0.152.2",
+  "hugoVersion": "0.152.2",
   "description": "Binary wrapper for Hugo",
   "repository": {
     "type": "git",
@@ -53,7 +53,7 @@
     "@xhmikosr/bin-check": "^7.1.0",
     "c8": "^10.1.3",
     "uvu": "^0.5.6",
-    "xo": "^1.2.2"
+    "xo": "^1.2.3"
   },
   "scripts": {
     "lint": "xo",
@@ -74,6 +74,10 @@
         "error",
         "always"
       ],
+      "@stylistic/operator-linebreak": [
+        "error",
+        "after"
+      ],
       "@stylistic/space-before-function-paren": [
         "error",
         "never"
@@ -86,10 +90,6 @@
         }
       ],
       "capitalized-comments": "off",
-      "operator-linebreak": [
-        "error",
-        "after"
-      ],
       "unicorn/prefer-top-level-await": "off",
       "unicorn/prevent-abbreviations": "off"
     }