enablement-build-manifest 1.0.4 → 1.4.0

package/README.md

@@ -10,24 +10,21 @@ npx enablement-build-manifest [options]
 
 Run from the root of your monorepo. The manifest is printed to stdout and optionally saved to disk.
 
-When using `--save`, existing `templated` package mappings and existing `cicd` hash/version fields in the target manifest are preserved.
+Every `--save` run converts the manifest to its current schema version: any template routing still recorded in the manifest is moved to `{configDir}/templates/templated.json`, any `cicd` hash values are moved to `{configDir}/hash.json`, and neither is kept in `manifest.json` afterward. `cicd` version fields are still preserved.
 
 ## Options
 
 | Flag | Description |
 |------|-------------|
 | `--save` | Write the manifest to `{configDir}/manifest.json` in addition to stdout |
-| `--platform <github\|ado>` | Override platform detection (default: auto-detected) |
+| `--platform <github|ado>` | Select the platform; defaults to `ado` |
+| `--children <dirs>` | Comma- or space-separated list of top-level directories to scan for packages (e.g. `packages,apps`). Overrides auto-detection from `pnpm-workspace.yaml` or `package.json` workspaces. |
+| `--exclude <dirs>` | Comma- or space-separated list of top-level directories to drop from whichever list of children is in effect — auto-detected or from `--children` (e.g. auto-detect everything in `pnpm-workspace.yaml` but skip `tools`). |
 | `--debug` | Print the number of discovered packages |
 
-## Platform Detection
+## Platform
 
-The platform is auto-detected by looking for the following files:
-
-- `.github/templates/templated.json` or `.github/manifest.json` → `github` (uses `.github/`)
-- Neither found → `ado` (uses `.cicd/`)
-
-Pass `--platform github` or `--platform ado` to override.
+The platform defaults to `ado`, which uses `.cicd/`. Pass `--platform github` to use `.github/`.
 
 ## Output
 
@@ -35,15 +32,19 @@ The manifest is a JSON object with six top-level keys:
 
 ```json
 {
+  "version":      2,
   "versions":     { "<package-name>": "<version>", ... },
   "dependencies": { "<package-name>": ["<local-dep>", ...], ... },
   "dependents":   { "<package-name>": ["<consumer>", ...], ... },
   "pipelines":    { "<template-file>": [ <stage>, ... ], ... },
-  "templated":    { "<template-file>": { "<placeholder>": { "<package-name>": "<job-template>", ... } } },
   "cicd":         { "<package-name>": { "output": "...", "language": "...", "tier": "...", ... }, ... }
 }
 ```
 
+### `version`
+
+The manifest's schema version. Always `2` in the current version of this tool.
+
 ### `versions`
 
 Maps every local package name to its current version from `package.json`.
@@ -57,21 +58,9 @@ Maps every local package name to its current version from `package.json`.
 
 Populated when `{configDir}/templates/templated.json` exists. Each key is a pipeline template filename; the value is an ordered list of resolved stages with their associated package lists.
 
-### `templated`
-
-Stores the template routing that used to live in `templated.json`. The first key is the output file name, the second key is the placeholder name, and the innermost map assigns each package name to the job template file or files it should use.
+### Template routing
 
-Example:
-
-```json
-{
-  "build.yml": {
-    "PACKAGES": {
-      "enablement-build-deploy-version": "build_node_component.yml"
-    }
-  }
-}
-```
+Template routing (which job template each package uses) no longer lives in `manifest.json` — it's read from and written to `{configDir}/templates/templated.json` directly, in the shape [packages/template-generate](../template-generate) expects: `{ "version": 2, "templated": { "<template-file>": { "<placeholder>": { "<package-name>": "<job-template>", ... } } }, "cicd": { "<package-name>": { "folderName": "...", "packageFolder": "...", "metadata": {...} } } }`. Every `--save` run migrates any leftover routing it finds in `manifest.json` into this file, additively (existing assignments in `templated.json` win over stale ones from `manifest.json`).
 
 ### `cicd`
 
@@ -87,6 +76,7 @@ CI/CD metadata for each package. Sourced from the `.cicd` field in `package.json
 | `pyproject.toml` present | `pypi` | `Python` | `api` |
 | `Dockerfile` in image/container path | `docker` | `Dockerfile` | `infra` |
 
+A `hash` field left over from an older manifest is moved to `{configDir}/hash.json` on the next `--save` and removed from `cicd`.
 
 ## Example
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enablement-build-manifest",
-  "version": "1.0.4",
+  "version": "1.4.0",
   "description": "This builds a dependency tree.",
   "type": "module",
   "module": "./index.mjs",
@@ -9,6 +9,7 @@
   "author": "Contributors",
   "dependencies": {
     "globby": "^16.2.0",
+    "minimatch": "~10.1.1",
     "yaml": "^2.8.1"
   },
   "scripts": {

package/src/dependencyOrder.mjs

@@ -0,0 +1,26 @@
+// Order `names` so that, as much as possible, each name comes after every
+// local dependency it has (per `dependencies`, a name -> [depName, ...] map —
+// the same shape as manifest.json's "dependencies" property). Dependencies
+// that aren't in `names` are ignored (they're outside whatever list is being
+// ordered). Cycles can't be fully resolved; when one is hit, the first member
+// reached is emitted without waiting on the rest, so this never hangs or
+// throws — it just orders what it safely can.
+export function topologicalSort(names, dependencies = {}) {
+  const nameSet = new Set(names);
+  const visited = new Set();
+  const result = [];
+
+  function visit(name, stack) {
+    if (visited.has(name) || stack.has(name)) return;
+    stack.add(name);
+    for (const dep of dependencies[name] || []) {
+      if (nameSet.has(dep)) visit(dep, stack);
+    }
+    stack.delete(name);
+    visited.add(name);
+    result.push(name);
+  }
+
+  for (const name of names) visit(name, new Set());
+  return result;
+}

package/src/detect.mjs

@@ -0,0 +1,48 @@
+import { globbySync } from 'globby';
+import path from 'path';
+
+// Classify a package's cicd output/language/tier/packageType from its package.json
+// contents and directory. Returns null when nothing matches.
+//
+// pkgPath is the absolute path to the package's package.json (matching the shape
+// generateManifest already has on hand); the package directory is derived from it.
+export function detectCicdType(pkgName, pkg, pkgPath) {
+  if (pkg['main'] || pkg['module']) {
+    const result = { output: 'npm', language: 'JavaScript', tier: 'component' };
+    if (pkg['bin']) {
+      result.packageType = 'cli';
+      result.tier = 'tooling';
+    }
+    return result;
+  }
+
+  if ((pkg['devDependencies'] && pkg['devDependencies']['moleculer']) || (pkg['dependencies'] && pkg['dependencies']['moleculer'])) {
+    return { output: 'npm', language: 'node', packageType: 'moleculer', tier: 'api' };
+  }
+
+  if ((pkg['devDependencies'] && pkg['devDependencies']['react']) || (pkg['dependencies'] && pkg['dependencies']['react'])) {
+    return { output: 'npm', language: 'JavaScript', packageType: 'ux', tier: 'ux' };
+  }
+
+  // not node
+  const pkgDir = path.dirname(pkgPath);
+  const csproj = globbySync('*.csproj', { cwd: pkgDir, absolute: true });
+  const toml = globbySync('pyproject.toml', { cwd: pkgDir, absolute: true });
+  const docker = globbySync('Dockerfile', { cwd: pkgDir, absolute: true });
+
+  if (csproj.length > 0) {
+    return { output: 'nuget', language: 'C#', packageType: 'dotnet', tier: 'api' };
+  }
+
+  if (toml.length > 0) {
+    const result = { output: 'pypi', language: 'Python', tier: 'api' };
+    if (pkgName.toLocaleLowerCase().endsWith('api')) result.packageType = 'pypi';
+    return result;
+  }
+
+  if (docker.length > 0 && (pkgPath.indexOf('image') >= 0 || pkgPath.indexOf('container') >= 0)) {
+    return { output: 'docker', language: 'Dockerfile', tier: 'infra' };
+  }
+
+  return null;
+}

package/src/hashFile.mjs

@@ -0,0 +1,502 @@
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { minimatch } from 'minimatch';
+
+// ─── hash.json file handling ─────────────────────────────────────────────────
+//
+// Hashes are always stored in a hash.json file, keyed by short package folder
+// name. When the requested --hashFile path points at a manifest.json (legacy
+// "manifest mode"), storage is redirected to a sibling hash.json instead of
+// writing hash data into the manifest.
+//
+// hash.json schema versions. 1 = legacy (flat map of name -> {hash, version,
+// fullName, packageFolder}, no wrapper). 2 = current (name -> hash string,
+// nested under a "hash" property, alongside a top-level "version"). Every
+// write stamps HASH_FILE_VERSION; version 1 is only ever inferred on read,
+// for files that predate the wrapper.
+const HASH_FILE_VERSION = 2;
+
+// Resolve the physical file used to store hash state, given the requested
+// hashFile path (relative to prefixPath).
+export function resolveHashFilePath(prefixPath, hashFile) {
+  const requestedHashFile = path.join(prefixPath, hashFile);
+  const usesManifestHashFile = hashFile.replace(/\\/g, '/').endsWith('/manifest.json');
+  const changeConfig = usesManifestHashFile
+    ? path.join(path.dirname(requestedHashFile), 'hash.json')
+    : requestedHashFile;
+  return { changeConfig, usesManifestHashFile };
+}
+
+// Create an empty hash file if it doesn't exist yet, so subsequent reads
+// always find valid JSON. Under options.try, only logs what would happen.
+export function ensureHashFileExists(changeConfig, options = {}) {
+  if (existsSync(changeConfig)) return;
+  if (options.try) {
+    console.log('\x1b[36m%s\x1b[0m', `[try] Hash file ${changeConfig} not found — treating previous state as empty`);
+  } else {
+    writeFileSync(changeConfig, "{}", "utf8");
+  }
+}
+
+// Load previously-recorded hashes, keyed by short package folder name, as
+// { name: { hash } }. Understands both the current format (hash values under
+// a "hash" property) and the legacy flat format, so callers never need to
+// know which one is on disk.
+export function loadHashFile(changeConfig) {
+  const data = existsSync(changeConfig) ? readFileSync(changeConfig, "utf8") : "{}";
+  const raw = JSON.parse(data || "{}");
+
+  if (raw.hash && typeof raw.hash === 'object') {
+    return Object.fromEntries(Object.entries(raw.hash).map(([name, hash]) => [name, { hash }]));
+  }
+
+  // Legacy format: { name: { hash, version?, fullName?, packageFolder? }, ... }
+  const { version, ...legacyEntries } = raw;
+  return Object.fromEntries(
+    Object.entries(legacyEntries).map(([name, entry]) => [name, { hash: entry && entry.hash }])
+  );
+}
+
+// Persist current hashes. Every write stamps the current schema version and
+// nests hash values (name -> hash string) under a "hash" property. In
+// manifest mode, only the touched packages' hashes are updated — every other
+// package already on disk is left alone. Otherwise, the file is fully
+// replaced with just the sorted current hash map.
+export function writeHashFile(changeConfig, current, { usesManifestHashFile }) {
+  let hashes;
+  if (usesManifestHashFile) {
+    const existing = loadHashFile(changeConfig);
+    Object.keys(current).forEach(name => {
+      existing[name] = { hash: current[name].hash };
+    });
+    hashes = Object.fromEntries(Object.entries(existing).map(([name, entry]) => [name, entry.hash]));
+  } else {
+    hashes = Object.fromEntries(Object.keys(current).sort().map(name => [name, current[name].hash]));
+  }
+  writeFileSync(changeConfig, JSON.stringify({ version: HASH_FILE_VERSION, hash: hashes }, null, 2), "utf8");
+}
+
+// ─── Recursive folder hashing ────────────────────────────────────────────────
+//
+// Hashes a file/folder tree, honoring include/exclude rules per file, folder,
+// and symbolic link. Adapted from the "folder-hash" package.
+
+const defaultOptions = {
+  algo: 'sha1', // see crypto.getHashes() for options
+  encoding: 'base64', // 'base64', 'base64url', 'hex' or 'binary'
+  files: {
+    exclude: [],
+    include: [],
+    matchBasename: true,
+    matchPath: false,
+    ignoreBasename: false,
+    ignoreRootName: false,
+  },
+  folders: {
+    exclude: [],
+    include: [],
+    matchBasename: true,
+    matchPath: false,
+    ignoreBasename: false,
+    ignoreRootName: false,
+  },
+  symbolicLinks: {
+    include: true,
+    ignoreBasename: false,
+    ignoreTargetPath: true,
+    ignoreTargetContent: false,
+    ignoreTargetContentAfterError: false,
+  },
+};
+
+const debug = function(txt) {
+  return params => {
+    console.log(txt, params);
+    return params;
+  }
+}
+
+// Use the environment variable DEBUG to log output, e.g. `set DEBUG=fhash:*`
+const log = {
+  match: function() {},
+  params: function(params) {return params},
+  err: debug('fhash:err'),
+  symlink: debug('fhash:symlink'),
+  queue: function() {}
+};
+
+function prep(fs) {
+  let queue = [];
+  let queueTimer = undefined;
+
+  function hashElement(name, dir, options, callback) {
+    callback = arguments[arguments.length - 1];
+
+    return parseParameters(arguments)
+      .then(({ basename, dir, options }) => {
+        // this is only used for the root level
+        options.skipMatching = true;
+        return fs.promises
+          .lstat(path.join(dir, basename))
+          .then(stats => {
+            stats.name = basename;
+            return stats;
+          })
+          .then(stats => hashElementPromise(stats, dir, options, true));
+      })
+      .then(result => {
+        if (isFunction(callback)) {
+          return callback(undefined, result);
+        } else {
+          return result;
+        }
+      })
+      .catch(reason => {
+        log.err('Fatal error:', reason);
+        if (isFunction(callback)) {
+          return callback(reason);
+        } else {
+          throw reason;
+        }
+      });
+  }
+
+  /**
+   * @param {fs.Stats} stats folder element, can also be of type fs.Dirent
+   * @param {string} dirname
+   * @param {Options} options
+   * @param {boolean} isRootElement
+   */
+  function hashElementPromise(stats, dirname, options, isRootElement = false) {
+    const name = stats.name;
+    let promise = undefined;
+    if (stats.isDirectory()) {
+      promise = hashFolderPromise(name, dirname, options, isRootElement);
+    } else if (stats.isFile()) {
+      promise = hashFilePromise(name, dirname, options, isRootElement);
+    } else if (stats.isSymbolicLink()) {
+      promise = hashSymLinkPromise(name, dirname, options, isRootElement);
+    } else {
+      log.err('hashElementPromise cannot handle ', stats);
+      return Promise.resolve({ name, hash: 'Error: unknown element type' });
+    }
+
+    return promise.catch(err => {
+      if (err.code && (err.code === 'EMFILE' || err.code === 'ENFILE')) {
+        log.queue(`queued ${dirname}/${name} because of ${err.code}`);
+
+        const promise = new Promise((resolve, reject) => {
+          queue.push(() => {
+            log.queue(`Will processs queued ${dirname}/${name}`);
+            return hashElementPromise(stats, dirname, options, isRootElement)
+              .then(ok => resolve(ok))
+              .catch(err => reject(err));
+          });
+        });
+
+        if (queueTimer === undefined) {
+          queueTimer = setTimeout(processQueue, 0);
+        }
+        return promise;
+      }
+
+      throw err;
+    });
+  }
+
+  function processQueue() {
+    queueTimer = undefined;
+    const runnables = queue;
+    queue = [];
+    runnables.forEach(run => run());
+  }
+
+  async function hashFolderPromise(name, dir, options, isRootElement = false) {
+    const folderPath = path.join(dir, name);
+    let ignoreBasenameOnce = options.ignoreBasenameOnce;
+    delete options.ignoreBasenameOnce;
+
+    if (options.skipMatching) {
+      // this is currently only used for the root folder
+      log.match(`skipped '${folderPath}'`);
+      delete options.skipMatching;
+    } else if (ignore(name, folderPath, options.folders)) {
+      return undefined;
+    }
+
+    const files = await fs.promises.readdir(folderPath, { withFileTypes: true });
+    const children = await Promise.all(
+      files
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(child => hashElementPromise(child, folderPath, options)),
+    );
+
+    if (ignoreBasenameOnce) options.ignoreBasenameOnce = true;
+    const hash = new HashedFolder(name, children.filter(notUndefined), options, isRootElement);
+    return hash;
+  }
+
+  function hashFilePromise(name, dir, options, isRootElement = false) {
+    const filePath = path.join(dir, name);
+
+    if (options.skipMatching) {
+      // this is currently only used for the root folder
+      log.match(`skipped '${filePath}'`);
+      delete options.skipMatching;
+    } else if (ignore(name, filePath, options.files)) {
+      return Promise.resolve(undefined);
+    }
+
+    return new Promise((resolve, reject) => {
+      try {
+        const hash = crypto.createHash(options.algo);
+        if (
+          options.files.ignoreBasename ||
+          options.ignoreBasenameOnce ||
+          (isRootElement && options.files.ignoreRootName)
+        ) {
+          delete options.ignoreBasenameOnce;
+          log.match(`omitted name of ${filePath} from hash`);
+        } else {
+          hash.update(name);
+        }
+
+        const f = fs.createReadStream(filePath);
+        f.on('error', err => {
+          reject(err);
+        });
+        f.pipe(hash, { end: false });
+
+        f.on('end', () => {
+          const hashedFile = new HashedFile(name, hash, options.encoding);
+          return resolve(hashedFile);
+        });
+      } catch (ex) {
+        return reject(ex);
+      }
+    });
+  }
+
+  async function hashSymLinkPromise(name, dir, options, isRootElement = false) {
+    const target = await fs.promises.readlink(path.join(dir, name));
+    log.symlink(`handling symbolic link ${name} -> ${target}`);
+    if (options.symbolicLinks.include) {
+      if (options.symbolicLinks.ignoreTargetContent) {
+        return symLinkIgnoreTargetContent(name, target, options, isRootElement);
+      } else {
+        return symLinkResolve(name, dir, target, options, isRootElement);
+      }
+    } else {
+      log.symlink('skipping symbolic link');
+      return Promise.resolve(undefined);
+    }
+  }
+
+  function symLinkIgnoreTargetContent(name, target, options, isRootElement) {
+    delete options.skipMatching; // only used for the root level
+    log.symlink('ignoring symbolic link target content');
+    const hash = crypto.createHash(options.algo);
+    if (!options.symbolicLinks.ignoreBasename && !(isRootElement && options.files.ignoreRootName)) {
+      log.symlink('hash basename');
+      hash.update(name);
+    }
+    if (!options.symbolicLinks.ignoreTargetPath) {
+      log.symlink('hash targetpath');
+      hash.update(target);
+    }
+    return Promise.resolve(new HashedFile(name, hash, options.encoding));
+  }
+
+  async function symLinkResolve(name, dir, target, options, isRootElement) {
+    delete options.skipMatching; // only used for the root level
+    if (options.symbolicLinks.ignoreBasename) {
+      options.ignoreBasenameOnce = true;
+    }
+
+    try {
+      const stats = await fs.promises.stat(path.join(dir, name));
+      stats.name = name;
+      const temp = await hashElementPromise(stats, dir, options, isRootElement);
+
+      if (!options.symbolicLinks.ignoreTargetPath) {
+        const hash = crypto.createHash(options.algo);
+        hash.update(temp.hash);
+        log.symlink('hash targetpath');
+        hash.update(target);
+        temp.hash = hash.digest(options.encoding);
+      }
+      return temp;
+    } catch (err) {
+      if (options.symbolicLinks.ignoreTargetContentAfterError) {
+        log.symlink(`Ignoring error "${err.code}" when hashing symbolic link ${name}`, err);
+        const hash = crypto.createHash(options.algo);
+        if (
+          !options.symbolicLinks.ignoreBasename &&
+          !(isRootElement && options.files.ignoreRootName)
+        ) {
+          hash.update(name);
+        }
+        if (!options.symbolicLinks.ignoreTargetPath) {
+          hash.update(target);
+        }
+        return new HashedFile(name, hash, options.encoding);
+      } else {
+        log.symlink(`Error "${err.code}": When hashing symbolic link ${name}`, err);
+        throw err;
+      }
+    }
+  }
+
+  function ignore(name, path, rules) {
+    if (rules.exclude) {
+      if (rules.matchBasename && rules.exclude(name)) {
+        log.match(`exclude basename '${name}'`);
+        return true;
+      } else if (rules.matchPath && rules.exclude(path)) {
+        log.match(`exclude path '${path}'`);
+        return true;
+      }
+    }
+    if (rules.include) {
+      if (rules.matchBasename && rules.include(name)) {
+        log.match(`include basename '${name}'`);
+        return false;
+      } else if (rules.matchPath && rules.include(path)) {
+        log.match(`include path '${path}'`);
+        return false;
+      } else {
+        log.match(`include rule failed for path '${path}'`);
+        return true;
+      }
+    }
+
+    log.match(`Will not ignore unmatched '${path}'`);
+    return false;
+  }
+
+  return hashElement;
+}
+
+function parseParameters(args) {
+  let basename = args[0],
+    dir = args[1],
+    options_ = args[2];
+
+  if (!isString(basename)) {
+    return Promise.reject(new TypeError('First argument must be a string'));
+  }
+
+  if (!isString(dir)) {
+    dir = path.dirname(basename);
+    basename = path.basename(basename);
+    options_ = args[1];
+  }
+
+  // parse options (fallback default options)
+  if (!isObject(options_)) options_ = {};
+  const options = {
+    algo: options_.algo || defaultOptions.algo,
+    encoding: options_.encoding || defaultOptions.encoding,
+    files: Object.assign({}, defaultOptions.files, options_.files),
+    folders: Object.assign({}, defaultOptions.folders, options_.folders),
+    match: Object.assign({}, defaultOptions.match, options_.match),
+    symbolicLinks: Object.assign({}, defaultOptions.symbolicLinks, options_.symbolicLinks),
+  };
+
+  // transform match globs to Regex
+  options.files.exclude = reduceGlobPatterns(options.files.exclude);
+  options.files.include = reduceGlobPatterns(options.files.include);
+  options.folders.exclude = reduceGlobPatterns(options.folders.exclude);
+  options.folders.include = reduceGlobPatterns(options.folders.include);
+
+  return Promise.resolve(log.params({ basename, dir, options }));
+}
+
+const HashedFolder = function HashedFolder(name, children, options, isRootElement = false) {
+  this.name = name;
+  this.children = children;
+
+  const hash = crypto.createHash(options.algo);
+  if (
+    options.folders.ignoreBasename ||
+    options.ignoreBasenameOnce ||
+    (isRootElement && options.folders.ignoreRootName)
+  ) {
+    delete options.ignoreBasenameOnce;
+    log.match(`omitted name of folder ${name} from hash`);
+  } else {
+    hash.update(name);
+  }
+  children.forEach(child => {
+    if (child.hash) {
+      hash.update(child.hash);
+    }
+  });
+
+  this.hash = hash.digest(options.encoding);
+};
+
+HashedFolder.prototype.toString = function (padding = '') {
+  const first = `${padding}{ name: '${this.name}', hash: '${this.hash}',\n`;
+  padding += '  ';
+
+  return `${first}${padding}children: ${this.childrenToString(padding)}}`;
+};
+
+HashedFolder.prototype.childrenToString = function (padding = '') {
+  if (this.children.length === 0) {
+    return '[]';
+  } else {
+    const nextPadding = padding + '  ';
+    const children = this.children.map(child => child.toString(nextPadding)).join('\n');
+    return `[\n${children}\n${padding}]`;
+  }
+};
+
+const HashedFile = function HashedFile(name, hash, encoding) {
+  this.name = name;
+  this.hash = hash.digest(encoding);
+};
+
+HashedFile.prototype.toString = function (padding = '') {
+  return padding + "{ name: '" + this.name + "', hash: '" + this.hash + "' }";
+};
+
+function isFunction(any) {
+  return typeof any === 'function';
+}
+
+function isString(str) {
+  return typeof str === 'string' || str instanceof String;
+}
+
+function isObject(obj) {
+  return obj !== null && typeof obj === 'object';
+}
+
+function notUndefined(obj) {
+  return typeof obj !== 'undefined';
+}
+
+function reduceGlobPatterns(globs) {
+  if (isFunction(globs)) {
+    return globs;
+  } else if (!globs || !Array.isArray(globs) || globs.length === 0) {
+    return undefined;
+  } else {
+    // combine globs into one single RegEx
+    const regex = new RegExp(
+      globs
+        .reduce((acc, exclude) => {
+          return acc + '|' + minimatch.makeRe(exclude).source;
+        }, '')
+        .substr(1),
+    );
+    return param => regex.test(param);
+  }
+}
+
+export const defaults = defaultOptions;
+export const hashElement = prep(fs);