filter-scan-dir 1.1.1 → 1.4.1

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# v1.3.0
+
+- `sortFiles` option
+- support filter callbacks returning `result.formatName`
+- CI
+- readme badges

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 Joel Chen
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,5 +1,15 @@
 # filter-scan-dir
 
+[![dependency status][deps-svg]][deps-url]
+[![dev dependency status][dev-deps-svg]][dev-deps-url]
+[![License][license-image]][license-url]
+[![build][build-image]][build-url]
+[![coverage][coverage-image]][coverage-url]
+
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][npm-badge-png]][package-url]
+
 Recursively scan and filter directory for a flat array of files.
 
 # Install
@@ -14,15 +24,15 @@ npm install --save filter-scan-dir
 const filterScanDir = require("filter-scan-dir");
 
 // sync
-const files = filterScanDir.sync({ dir: "test" });
+const files = filterScanDir.sync({ cwd: "test" });
 console.log(files);
 
 // async
-filterScanDir({ dir: "test" }).then(files => {
+filterScanDir({ cwd: "test" }).then((files) => {
   console.log(files);
 });
 
-console.log(await filterScanDir({ dir: "test" }));
+console.log(await filterScanDir({ cwd: "test" }));
 ```
 
 ## API
@@ -33,17 +43,20 @@ Sync version: `filterScanDir.sync`
 
 `options`:
 
-| name          | description                                                                | default    |
-| ------------- | -------------------------------------------------------------------------- | ---------- |
-| `dir`         | root directory to start scanning                                           |            |
-| `includeRoot` | add the root dir to the result                                             |            |
-| `filter`      | callback to filter files. it should return filter result.                  |            |
-| `ignoreExt`   | array or string of extensions to ignore. ext must include `.`, ie: `".js"` |            |
-| `filterExt`   | array or string of extensions to include only, apply after `ignoreExt`.    |            |
-| `filterDir`   | callback to filter directories. it should return filter result             |            |
-| `includeDir`  | include directories in result if `true`                                    |            |
-| `grouping`    | enable [grouping](#grouping) if `true`                                     |            |
-| `maxLevel`    | zero base max level of directories to recurse into                         | `Infinity` |
+| name           | description                                                                | default         |
+| -------------- | -------------------------------------------------------------------------- | --------------- |
+| `cwd`          | current working directory to start scanning                                | `process.cwd()` |
+| `prefix`       | prefix to add to the paths to scan                                         |                 |
+| `prependCwd`   | prepend CWD to paths returned                                              | `false`         |
+| `sortFiles`    | sort files from each dir if `true`.                                        | `false`         |
+| `filter`       | callback to filter files. it should return filter result.                  |                 |
+| `ignoreExt`    | array or string of extensions to ignore. ext must include `.`, ie: `".js"` |                 |
+| `filterExt`    | array or string of extensions to include only, apply after `ignoreExt`.    |                 |
+| `filterDir`    | callback to filter directories. it should return filter result             |                 |
+| `includeDir`   | include directories in result if `true`                                    |                 |
+| `grouping`     | enable [grouping](#grouping) if `true`                                     |                 |
+| `maxLevel`     | zero base max level of directories to recurse into                         | `Infinity`      |
+| `rethrowError` | set to `true` to throw errors instead of ignoring them                     | `false`         |
 
 `filterDir` and `filter` callback signature:
 
@@ -61,16 +74,17 @@ params:
 | `extras.dirFile`  | `Path.join(path, file)`                        |
 | `extras.ext`      | extension of the file including `.`, ie: `.js` |
 | `extras.noExt`    | file name without the extension                |
-| `extras.fullFile` | `Path.join(rootDir, path, file)`               |
+| `extras.fullFile` | `Path.join(cwd, path, file)`                   |
 
 should return filter result:
 
 - `false` - skip the file or directory
 - _string_ - name of the group to add the file or directory (need to enable [grouping](#grouping))
-- _object_ - `{ group, skip, stop }` where:
+- _object_ - `{ group, skip, stop, formatName }` where:
   - `group` - name of the group to add the file or directory (need to enable [grouping](#grouping))
   - `skip` - if `true` then skip the file or directory, else add it.
-  - `stop` - stop the scanning and return the result immediately
+  - `stop` - stop the scanning and return the result immediately.
+  - `formatName` - if not `undefined`, then use this as the value to add to the output.
 
 ## grouping
 
@@ -98,7 +112,7 @@ If you really want to force using Windows `\`, then you can pass in `options._pa
 
 ```js
 const path = require("path");
-scanDir({ dir: "test", _path: path });
+scanDir({ cwd: "test", _path: path });
 ```
 
 > Internally this is default to `require("path").posix`.
@@ -108,3 +122,19 @@ If you only want to keep `\` in the dir you passed in, then you can just set `_p
 # License
 
 Licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)
+
+[npm-version-svg]: https://badge.fury.io/js/filter-scan-dir.svg
+[package-url]: https://npmjs.com/package/filter-scan-dir
+[deps-svg]: https://david-dm.org/filter-scan-dir.svg
+[deps-url]: https://david-dm.org/filter-scan-dir
+[dev-deps-svg]: https://david-dm.org/filter-scan-dir/dev-status.svg
+[dev-deps-url]: https://david-dm.org/filter-scan-dir#info=devDependencies
+[license-image]: https://img.shields.io/npm/l/filter-scan-dir.svg
+[license-url]: LICENSE
+[build-image]: https://github.com/jchip/filter-scan-dir/actions/workflows/node.js.yml/badge.svg
+[build-url]: https://github.com/jchip/filter-scan-dir/actions/workflows/node.js.yml
+[coverage-image]: https://coveralls.io/repos/github/jchip/filter-scan-dir/badge.svg?branch=main
+[coverage-url]: https://coveralls.io/github/jchip/filter-scan-dir?branch=main
+[downloads-image]: https://img.shields.io/npm/dm/filter-scan-dir.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=filter-scan-dir
+[npm-badge-png]: https://nodei.co/npm/filter-scan-dir.png?downloads=true&stars=true

package/lib/index.js

@@ -1,83 +1,99 @@
 "use strict";
 
-/* eslint-disable max-statements, complexity */
+/* eslint-disable max-statements, complexity, comma-dangle, max-params */
 
 const Fs = require("fs");
 const Path = require("path");
 const Util = require("util");
 
-function process(file, options, extras) {
-  let dirFile = options._path.join(extras.path, file);
-
+function makeExtrasData(file, fullFile, path, stat, options) {
+  const dirFile = options._path.join(path, file);
   const ix = file.lastIndexOf(".");
 
   if (ix > 0) {
-    extras.ext = file.substr(ix);
-    extras.noExt = file.substring(0, ix);
+    return {
+      file,
+      path,
+      stat,
+      fullFile,
+      dirFile,
+      ext: file.substr(ix),
+      noExt: file.substring(0, ix),
+    };
   } else {
-    extras.ext = "";
-    extras.noExt = file;
+    return {
+      file,
+      path,
+      stat,
+      fullFile,
+      dirFile,
+      ext: "",
+      noExt: file,
+    };
   }
+}
 
-  extras.dirFile = dirFile;
-
-  const add = result => {
-    const group =
-      (options.grouping && typeof result === "string"
-        ? result
-        : result && result.group) || "files";
+function addResult(result, options, extras) {
+  const group =
+    (options.grouping && typeof result === "string"
+      ? result
+      : result && result.group) || "files";
 
-    if (!options.result[group]) {
-      options.result[group] = [];
-    }
+  if (!options.result[group]) {
+    options.result[group] = [];
+  }
 
-    options.result[group].push(options.includeRoot ? extras.fullFile : dirFile);
-  };
+  if (result.formatName !== undefined) {
+    options.result[group].push(result.formatName);
+  } else {
+    options.result[group].push(
+      options.prependCwd ? extras.fullFile : extras.dirFile
+    );
+  }
+}
 
-  let filterResult;
+function processDir(options, extras) {
+  const filterResult = options.filterDir
+    ? options.filterDir(extras.file, extras.path, extras)
+    : true;
 
-  if (extras.stat.isDirectory()) {
-    if (options.filterDir) {
-      filterResult = options.filterDir(file, extras.path, extras);
-    } else {
-      filterResult = true;
+  if (filterResult) {
+    if (filterResult.skip !== true && options.includeDir) {
+      addResult(filterResult, options, extras);
     }
+    return { stop: filterResult.stop, skip: filterResult.skip };
+  }
 
-    if (filterResult && filterResult.skip !== true) {
-      if (options.includeDir) {
-        add(filterResult);
-      }
-    } else {
-      dirFile = undefined;
-    }
-  } else {
-    if (
-      options.ignoreExt.length > 0 &&
-      options.ignoreExt.indexOf(extras.ext) >= 0
-    ) {
-      return false;
-    }
-    if (
-      options.filterExt.length > 0 &&
-      options.filterExt.indexOf(extras.ext) < 0
-    ) {
-      return false;
-    }
+  return { stop: false, skip: true };
+}
 
-    if (options.filter) {
-      filterResult = options.filter(file, extras.path, extras);
-    } else {
-      filterResult = true;
-    }
+function processFile(options, extras) {
+  if (
+    options.ignoreExt.length > 0 &&
+    options.ignoreExt.indexOf(extras.ext) >= 0
+  ) {
+    return false;
+  }
 
-    if (filterResult && filterResult.skip !== true) {
-      add(filterResult);
-    }
+  if (
+    options.filterExt.length > 0 &&
+    options.filterExt.indexOf(extras.ext) < 0
+  ) {
+    return false;
+  }
 
-    dirFile = undefined;
+  const filterResult = options.filter
+    ? options.filter(extras.file, extras.path, extras)
+    : true; // default to include
+
+  if (filterResult) {
+    if (filterResult.skip !== true) {
+      addResult(filterResult, options, extras);
+    }
+    return filterResult.stop;
   }
 
-  return { dirFile, stop: filterResult && filterResult.stop };
+  return false;
 }
 
 function getResult(options) {
@@ -89,68 +105,113 @@ function getResult(options) {
 function walkSync(path, options, level = 0) {
   try {
     const dir = options._path.join(options.dir, path);
-    const files = Fs.readdirSync(dir);
+    let files = Fs.readdirSync(dir);
+
+    if (options.sortFiles) {
+      files = files.sort();
+    }
+
+    const dirs = [];
+    let stop = false;
 
-    for (const file of files) {
+    // process files first
+    for (let ix = 0; !stop && ix < files.length; ix++) {
+      const file = files[ix];
       const fullFile = options._path.join(dir, file);
-      const stat = Fs.statSync(fullFile);
-      const result = process(file, options, { path, stat, fullFile });
+      const stat = Fs.lstatSync(fullFile);
 
-      if (result) {
-        if (result.stop) {
+      const extras = makeExtrasData(file, fullFile, path, stat, options);
+
+      if (stat.isDirectory()) {
+        dirs.push(extras);
+      } else {
+        stop = processFile(options, extras);
+      }
+    }
+
+    // now process dirs
+    if (!stop && dirs.length > 0) {
+      for (let ix = 0; ix < dirs.length; ix++) {
+        const extras = dirs[ix];
+        const flags = processDir(options, extras);
+        if (flags.stop) {
           break;
         }
-
-        if (result.dirFile && level < options.maxLevel) {
-          walkSync(result.dirFile, options, level + 1);
+        if (!flags.skip && level < options.maxLevel) {
+          walkSync(extras.dirFile, options, level + 1);
         }
       }
     }
   } catch (err) {
-    // console.log(err);
+    if (options.rethrowError) {
+      throw err;
+    }
   }
 
   return getResult(options);
 }
 
 const asyncReaddir = Util.promisify(Fs.readdir);
-const asyncStat = Util.promisify(Fs.stat);
+const asyncLStat = Util.promisify(Fs.lstat);
 
 async function walk(path, options, level = 0) {
   try {
     const dir = options._path.join(options.dir, path);
-    const files = await asyncReaddir(dir);
+    let files = await asyncReaddir(dir);
+
+    if (options.sortFiles) {
+      files = files.sort();
+    }
 
-    for (const file of files) {
+    const dirs = [];
+    let stop = false;
+
+    // process files first
+    for (let ix = 0; !stop && ix < files.length; ix++) {
+      const file = files[ix];
       const fullFile = options._path.join(dir, file);
-      const stat = await asyncStat(fullFile);
-      const result = process(file, options, { path, stat, fullFile });
 
-      if (result) {
-        if (result.stop) {
+      const stat = await asyncLStat(fullFile);
+      const extras = makeExtrasData(file, fullFile, path, stat, options);
+      if (stat.isDirectory()) {
+        dirs.push(extras);
+      } else {
+        stop = processFile(options, extras);
+      }
+    }
+
+    // now process dirs
+    if (!stop && dirs.length > 0) {
+      for (let ix = 0; ix < dirs.length; ix++) {
+        const extras = dirs[ix];
+        const flags = processDir(options, extras);
+        if (flags.stop) {
           break;
         }
-
-        if (result.dirFile && level < options.maxLevel) {
-          await walk(result.dirFile, options, level + 1);
+        if (!flags.skip && level < options.maxLevel) {
+          await walk(extras.dirFile, options, level + 1);
         }
       }
     }
   } catch (err) {
-    // console.log(err);
+    if (options.rethrowError) {
+      throw err;
+    }
   }
 
   return getResult(options);
 }
 
 function makeOptions(options) {
-  let dir = typeof options === "string" ? options : options.dir;
+  let cwd =
+    (typeof options === "string" ? options : options.cwd || options.dir) ||
+    process.cwd();
 
-  if (!options._path && dir.indexOf("\\") >= 0) {
-    dir = dir.replace(/\\/g, "/");
+  if (!options._path && cwd.indexOf("\\") >= 0) {
+    cwd = cwd.replace(/\\/g, "/");
   }
 
-  const cleanExt = ext => {
+  const cleanExt = (ext) => {
     if (!ext) {
       return ext;
     }
@@ -163,26 +224,37 @@ function makeOptions(options) {
     return ext;
   };
 
-  return Object.assign({ _path: Path.posix, maxLevel: Infinity }, options, {
-    dir,
-    result: {},
-    ignoreExt: []
-      .concat(options.ignoreExt)
-      .map(cleanExt)
-      .filter(x => x),
-    filterExt: []
-      .concat(options.filterExt)
-      .map(cleanExt)
-      .filter(x => x)
-  });
+  const prependCwd =
+    (options.hasOwnProperty("includeRoot")
+      ? options.includeRoot
+      : options.prependCwd) || false;
+
+  return Object.assign(
+    { _path: Path.posix, maxLevel: Infinity, prefix: "", prependCwd },
+    options,
+    {
+      dir: cwd,
+      result: {},
+      ignoreExt: []
+        .concat(options.ignoreExt)
+        .map(cleanExt)
+        .filter((x) => x),
+      filterExt: []
+        .concat(options.filterExt)
+        .map(cleanExt)
+        .filter((x) => x),
+    }
+  );
 }
 
 function filterScanDir(options) {
-  return walk("", makeOptions(options));
+  const options2 = makeOptions(options);
+  return walk(options2.prefix, options2);
 }
 
 filterScanDir.sync = function filterScanDirSync(options) {
-  return walkSync("", makeOptions(options));
+  const options2 = makeOptions(options);
+  return walkSync(options2.prefix, options2);
 };
 
 module.exports = filterScanDir;

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "filter-scan-dir",
-  "version": "1.1.1",
+  "version": "1.4.1",
   "description": "Recursively scan and filter directory for a flat array of files",
   "main": "lib/index.js",
   "scripts": {
     "test": "clap test-only",
+    "lint": "clap lint",
+    "coveralls": "cat coverage/lcov.info | coveralls",
     "coverage": "clap check",
+    "ci:check": "clap -n --serial check coveralls",
+    "prepack": "publish-util-prepack",
     "postpack": "publish-util-postpack"
   },
   "repository": {