@metalsmith/collections 1.1.0 → 1.2.2

package/CHANGELOG.md

@@ -1,18 +1,36 @@
 ### Changelog
 
-All notable changes to this project will be documented in this file. Dates are displayed in UTC.
+#### [v1.2.2](https://github.com/metalsmith/collections/compare/v1.2.2...v1.2.1) / 2022-07-28
 
-Generated by [`auto-changelog`](https://github.com/CookPete/auto-changelog).
+- Resolves [`#102`](https://github.com/metalsmith/collections/issues/99): removes multimatch dependency, uses metalsmith.match instead
+- Drops support for Metalsmith < 2.4.1
+- Drops support for Node < 12
 
-#### [v1.1.0](https://github.com/metalsmith/collections/compare/v1.0.0...v1.1.0)
+#### [v1.2.1](https://github.com/metalsmith/collections/compare/v1.2.1...v1.2.0) / 2022-02-03
+
+- Fixes [`#99`](https://github.com/metalsmith/collections/issues/99): collection key on file metadata - no dupes, no nested arrays
+- Fixes regression: incorrect previous & next refs when reverse: true
+- Fixes typo's in README
+
+#### [v1.2.0](https://github.com/metalsmith/collections/compare/v1.2.0...v1.1.0) / 2022-01-29
+
+- Feature: sortBy now also understands nested metadata properties, e.g. `sortBy: 'meta.display.order'`
+- Fixed JSDoc typo that made type hints unavailable
+- Documented limit & refer options
+- Improved README.md with more elaborate examples
+- Refactored to cleaner code
+- Removed dependencies: `extend`,`uniq`
+- Added dependency `lodash.get`
+- Added core-plugin tests
+- Updated devDependencies release-it, prettier, eslint
+
+#### [v1.1.0](https://github.com/metalsmith/collections/compare/v1.0.0...v1.1.0) / 2021-15-12
 
 - Added standardised code formatting and QA [`#86`](https://github.com/metalsmith/collections/pull/86)
 - Updated History with v1 PRs [`#85`](https://github.com/metalsmith/collections/pull/85)
 - Added better JSDoc types, return named plugin function [`3aa3443`](https://github.com/metalsmith/collections/commit/3aa3443802c2f814c90cf39c7b43de8fc3d3ff13)
 - Updated multimatch to 4.0.0, debug to 4.3.3 [`71d6f65`](https://github.com/metalsmith/collections/commit/71d6f65b9ec5572196e17dfebf5cff2361853f9d)
 
-<!-- auto-changelog-above -->
-
 # [1.0.0][] / 2018-10-17
 
 - Fixed API and merged many PRs

package/README.md

@@ -1,6 +1,6 @@
 # @metalsmith/collections
 
-A [Metalsmith](https://github.com/metalsmith/metalsmith) plugin that lets you group files together into an ordered collection, like blog posts. That way you can loop over them to generate an index, or add 'next' and 'previous' links between them.
+A Metalsmith plugin that lets you group files together into ordered collections, like blog posts. That way you can loop over them to generate index pages, add 'next' and 'previous' links between them, and more
 
 [![metalsmith: core plugin][metalsmith-badge]][metalsmith-url]
 [![npm version][npm-badge]][npm-url]
@@ -10,10 +10,10 @@ A [Metalsmith](https://github.com/metalsmith/metalsmith) plugin that lets you gr
 
 ## Features
 
-- can match files by `collection` metadata
+- can match files by `collection` file metadata
 - can match files by pattern
 - can limit the number of files in a collection
-- can filter files in a collection based on metadata
+- can filter files in a collection based on file metadata
 - adds collections to global metadata
 - adds `next` and `previous` references to each file in the collection
 
@@ -21,102 +21,183 @@ A [Metalsmith](https://github.com/metalsmith/metalsmith) plugin that lets you gr
 
 NPM:
 
-```
+```bash
 npm install @metalsmith/collections
 ```
 
 Yarn:
 
-```
+```bash
 yarn add @metalsmith/collections
 ```
 
 ## Usage
 
-There are two ways to create collections (they can be used together):
-
-- **by pattern** - this is just passing a globbing pattern that will group any files that match into the same collection. The passed pattern can be a single pattern (as a string) or an array of globing patterns. For more information read the [multimatch patterns documentation](https://www.npmjs.com/package/multimatch#how-multiple-patterns-work).
-- **by metadata** - this is adding a specific `collection` metadata field to each item that you want to add to a collection.
-
-The simplest way to create a collection is to use a pattern to match the files you want to group together:
+Pass options to `@metalsmith/collections` in the plugin chain:
 
 ```js
+const Metalsmith = require('metalsmith')
+const markdown = require('@metalsmith/markdown')
 const collections = require('@metalsmith/collections')
 
-metalsmith.use(
-  collections({
-    articles: '*.md'
+// defaults, only create collections based on file metadata
+Metalsmith(__dirname)
+  .use(markdown())
+  .use(collections())
+
+// defaults for a "news" collection, except pattern option
+Metalsmith(__dirname)
+  .use(markdown())
+  .use(collections({
+    news: { pattern: 'news/**/*.html' }
+  }))
+
+// explicit defaults for a "news" collection, except pattern option
+Metalsmith(__dirname)
+  .use(markdown())
+  .use(collections({
+    pattern: { pattern: 'news/**/*.html' },
+    metadata: null,
+    filterBy: () => true,
+    sortBy: defaultSort,
+    reverse: false,
+    limit: Infinity,
+    refer: true
   })
-)
 ```
 
-Which is just a shorthand. You could also add additional options:
+_Note: all examples in the readme use the same collections definitions under [Defining collections](#defining-collections)_
 
-```js
-metalsmith.use(
-  collections({
-    articles: {
-      pattern: '*.md',
-      sortBy: 'date',
-      reverse: true
-    }
-  })
-)
-```
+### Options
 
-But you can also match based on a `collection` property in each file's metadata by omitting a pattern, and adding the property to your files:
+All options are _optional_
 
-```js
-metalsmith.use(
-  collections({
-    articles: {
-      sortBy: 'date',
-      reverse: true
-    }
-  })
-)
-```
+- **pattern** `string|string[]` - one or more glob patterns to group files into a collection
+- **filterBy** `Function` - a function that returns `false` for files that should be filtered _out_ of the collection
+- **limit** `number` - restrict the number of files in a collection to at most `limit`
+- **sortBy** `string|Function` - a file metadata key to sort by (for example `date` or `pubdate` or `title`), or a custom sort function
+- **reverse** `boolean` - whether the sort should be reversed (e.g., for a news/blog collection, you typically want `reverse: true`)
+- **metadata** `Object|string` - metadata to attach to the collection. Will be available as `metalsmith.metadata().collections.<name>.metadata`. This can be used for example to attach metadata for index pages. _If a string is passed, it will be interpreted as a file path to an external `JSON` or `YAML` metadata file_
+- **refer** `boolean` - will add `previous` and `next` keys to each file in a collection. `true` by default
 
-```markdown
----
-title: My Article
-collection: articles
-date: 2021-12-01
----
+### Defining collections
 
-My article contents...
-```
+There are 2 ways to create collections & they can be used together:
 
-Multiple collections can also be assigned per file:
+- **by pattern** - for example, this is how you would create multiple pattern-based collections, based on the folders `photos`, `news`, and `services`:
 
-```markdown
----
-title: My Article
-collection:
-  - articles
-  - news
-date: 2021-12-01
----
+  ```js
+  metalsmith.use(
+    collections({
+      gallery: 'photos/**/*.{jpg,png}',
+      news: {
+        metadata: {
+          title: 'Latest news',
+          description: 'All the latest in politics & world news',
+          slug: 'news'
+        },
+        pattern: 'news/**/*.html',
+        sortBy: 'pubdate',
+        reverse: true
+      },
+      services: 'services/**/*.html'
+    })
+  )
+  ```
 
-My article contents...
-```
+- **by file metadata** - add a `collection` property to the front-matter of each file that you want to add to a collection. The markdown file below will be included in the `news` collection even if it's not in the `news` folder (see previous example)
+
+  `something-happened.md`
+
+  ```md
+  ---
+  title: Something happened
+  collection: news
+  pubdate: 2021-12-01
+  layout: news.hbs
+  ---
+
+  ...contents
+  ```
+
+  Note that you can also add the same file to multiple collections, which is useful for example if you want to use `@metalsmith/collections` as a _category_ system:
 
-All of the files with a matching `collection` will be added to an array that is exposed as a key of the same name on the global Metalsmith `metadata`.
-You can omit passing any options to the plugin when matching based on a `collection` property.
+  `something-happened.md`
 
-Adds a `path` property to the collection item's data which contains the file path of the generated file. For example, this can be used in mustache templates to create links:
+  ```md
+  title: Something happened
+  collection:
 
-```html
-<h1><a href="/{{ path }}">{{ title }}</a></h1>
+  - news
+  - category_politics
+  - category_world
+    pubdate: 2021-12-01
+    layout: news.hbs
+
+  ---
+
+  ...contents
+  ```
+
+### Rendering collection items
+
+Here is an example of using [@metalsmith/layouts](https://github.com/metalsmith/layouts) with [jstransformer-handlebars](https://github.com/jstransformers/jstransformer-handlebars) to render the `something-happened.md` news item, with links to the next and previous news items (using `refer: true` options):
+
+`layouts/news.njk`
+
+```handlebars
+<h1>{{ title }}</h1> {{!-- something-happened.md title --}}
+<a href="/{{ collections.news.metadata.slug }}">Back to news</a> {{!-- news collection metadata.slug --}}
+{{ contents | safe }}
+<hr>
+{{!-- previous & next are added by @metalsmith/collections --}}
+{{#if previous}}
+Read the previous news:
+<a href="/{{ previous.path }}">{{ previous.title }}</a>
+{{/if}}
+{{#if next}}
+Read the next news:
+<a href="/{{ next.path }}">{{ next.title }}</a>
+{{/if}}
+```
+
+_Note: If you don't need the `next` and `previous` references, you can pass the option `refer: false`_
+
+### Rendering collection index
+
+All matched files are added to an array that is exposed as a key of metalsmith global metadata, for example the `news` collection would be accessible at `Metalsmith.metadata().collections.news `. Below is an example of how you could render an index page for the `news` collection:
+
+`layouts/news-index.hbs`
+
+```handlebars
+<h1>{{ title }}</h1> {{!-- news collection metadata.title --}}
+<p>{{ description }}</p> {{!-- news collection metadata.description --}}
+<hr>
+{{!-- previous & next are added by @metalsmith/collections --}}
+{{#if collections.news.length }}
+  <ul>
+  {{#each collections.news}}
+    <li>
+      <h3><a href="/{{path}}">{{ title }}</a></h3>
+      <p>{{ excerpt }}</p>
+    </li>
+  {{/each}}
+  </ul>
+{{/each}}
+{{else}}
+No news at the moment...
+{{/if}}
 ```
 
-The sorting method can be overridden with a custom function in order to sort the files in any order you prefer. For instance, this function sorts the "subpages" collection by a numerical "index" property but places unindexed items last.
+### Custom sorting, filtering and limiting
+
+You could define an `order` property on a set of files and pass `sortBy: "order"` to `@metalsmith/collections` for example, or you could override the sort with a custom function (for example to do multi-level sorting). For instance, this function sorts the "subpages" collection by a numerical "index" property but places unindexed items last.
 
 ```js
 metalsmith.use(
   collections({
     subpages: {
-      sortBy: function(a, b) {
+      sortBy: function (a, b) {
         let aNum, bNum
 
         aNum = +a.index
@@ -137,63 +218,65 @@ metalsmith.use(
 )
 ```
 
-The `filterBy` function is passed a single argument which corresponds to each file's metadata. You can use the metadata to perform comparisons or carry out other decision-making logic. If the function you supply evaluates to `true`, the file will be added to the collection. If it evaluates to `false`, the file will not be added.
+_Note: the `sortBy` option also understands nested keypaths, e.g. `display.order`_
 
-### Collection Metadata
-
-Additional metadata can be added to the collection object.
+The `filterBy` function is passed a single argument which corresponds to each file's metadata. You can use the metadata to perform comparisons or carry out other decision-making logic. If the function you supply evaluates to `true`, the file will be added to the collection. If it evaluates to `false`, the file will not be added. The filterBy function below could work for a collection named `thisYearsNews` as it would filter out all the items that are older than this year:
 
 ```js
-metalsmith.use(
-  collections({
-    articles: {
-      sortBy: 'date',
-      reverse: true,
-      metadata: {
-        name: 'Articles',
-        description: 'The Articles listed here...'
-      }
-    }
-  })
-)
+function filterBy(file) {
+  const today = new Date()
+  const pubdate = new Date(file.pubdate)
+  return pubdate.getFullYear() === today.getFullYear()
+}
 ```
 
-Collection metadata can also be assigned from a `json` or `yaml` file.
+Add a `limit` option to a collection config, for example to separate recent articles from archives:
 
 ```js
 metalsmith.use(
   collections({
-    articles: {
+    recentArticles: {
+      pattern: 'articles/**/*.html',
       sortBy: 'date',
-      reverse: true,
-      metadata: 'path/to/file.json'
+      limit: 10
+    },
+    archives: {
+      pattern: 'archives/**/*.html',
+      sortBy: 'date'
     }
   })
 )
 ```
 
-On each collection definition, it's possible to add a `limit` option so that the
-collection length is not higher than the given limit:
+_Note: the collection is first sorted, reversed, filtered, and then limited, if applicable._
+
+### Collection Metadata
+
+Additional metadata can be added to the collection object:
 
 ```js
 metalsmith.use(
   collections({
-    lastArticles: {
-      sortBy: 'date',
-      limit: 10
+    news: {
+      metadata: {
+        title: 'Latest news',
+        description: 'All the latest in politics & world news',
+        slug: 'news'
+      }
     }
   })
 )
 ```
 
-By adding `refer: false` to your options, it will skip adding the "next" and
-"previous" links to your articles.
+Collection metadata can be loaded from a `json` or `yaml` file (path relative to `Metalsmith.directory()`):
 
 ```js
 metalsmith.use(
   collections({
     articles: {
-      refer: false
+      sortBy: 'date',
+      reverse: true,
+      metadata: 'path/to/file.json'
     }
   })
 )
@@ -240,8 +323,8 @@ Add the `@metalsmith/collections` key to your `metalsmith.json` `plugins` key:
 
 [npm-badge]: https://img.shields.io/npm/v/@metalsmith/collections.svg
 [npm-url]: https://www.npmjs.com/package/@metalsmith/collections
-[ci-badge]: https://app.travis-ci.com/github/metalsmith/collections.svg?branch=master
-[ci-url]: https://app.travis-ci.com/github/metalsmith/collections
+[ci-badge]: https://github.com/metalsmith/collections/actions/workflows/test.yml/badge.svg
+[ci-url]: https://github.com/metalsmith/collections/actions/workflows/test.yml
 [metalsmith-badge]: https://img.shields.io/badge/metalsmith-plugin-green.svg?longCache=true
 [metalsmith-url]: http://metalsmith.io
 [codecov-badge]: https://img.shields.io/coveralls/github/metalsmith/collections

package/lib/index.js

@@ -1,236 +1,194 @@
-var debug = require('debug')('@metalsmith/collections')
-var multimatch = require('multimatch')
-var unique = require('uniq')
-var loadMetadata = require('read-metadata').sync
+const debug = require('debug')('@metalsmith/collections')
+const loadMetadata = require('read-metadata').sync
+const get = require('lodash.get')
+// for backwards-compatibility only, date makes as little sense as "pubdate" or any custom key
+const defaultSort = sortBy('date')
+const defaultFilter = () => true
 
 /**
- * Expose `plugin`.
+ * @typedef {Object} CollectionConfig
+ * @property {string|string[]} pattern - One or more glob patterns to match files to a collection
+ * @property {string|(a,b) => 0|1|-1} sortBy - A key to sort by (e.g. `date`,`title`, ..) or a custom sort function
+ * @property {number} limit - Limit the amount of items in a collection to `limit`
+ * @property {boolean} refer - Adds `next` and `previous` keys to file metadata of matched files
+ * @property {boolean} reverse - Whether to invert the sorting function results (asc/descending)
+ * @property {Function} filterBy - A function that gets a `Metalsmith.File` as first argument and returns `true` for every file to include in the collection
+ * @property {Object|string} metadata - An object with metadata to attach to the collection, or a `json`/`yaml`filepath string to load data from (relative to `Metalsmith.directory`)
  */
 
-module.exports = plugin
+/** @type {CollectionConfig} */
+const defaultOptions = {
+  pattern: null,
+  reverse: false,
+  metadata: null,
+  limit: Infinity,
+  refer: true,
+  sortBy: defaultSort,
+  filterBy: defaultFilter
+}
+
+function sortBy(key) {
+  let getKey = (x) => x[key]
+  if (key.includes('.')) {
+    getKey = (x) => get(x, key)
+  }
+  return function defaultSort(a, b) {
+    a = getKey(a)
+    b = getKey(b)
+    if (!a && !b) return 0
+    if (!a) return -1
+    if (!b) return 1
+    if (b > a) return -1
+    if (a > b) return 1
+    return 0
+  }
+}
 
 /**
- * @typedef {Object} CollectionConfig
- * @property {String|String[]} pattern - One or more glob patterns to match files to a collection
- * @property {'date'|Function} sortBy
- * @property {Boolean} reverse - Whether to invert the sorting function results (asc/descending)
- * @property {Function} filterBy - A function that gets a `Metalsmith.File` as first argument and returns `true` for every file to include in the collection
- * @property {Object} metadata - An object with metadata to attach to the collection
+ * Normalize options
+ * @param {Object.<string,CollectionConfig>} options
  */
+function normalizeOptions(options) {
+  options = options || {}
+
+  for (const config in options) {
+    let normalized = options[config]
+    if (typeof normalized === 'string' || Array.isArray(normalized)) {
+      normalized = { pattern: normalized }
+    }
+    normalized = Object.assign({}, defaultOptions, normalized)
+    if (typeof normalized.metadata === 'string') {
+      normalized.metadata = loadMetadata(normalized.metadata)
+    }
+    if (typeof normalized.sortBy === 'string') {
+      normalized.sortBy = sortBy(normalized.sortBy)
+    }
+    options[config] = normalized
+  }
+
+  return options
+}
 
 /**
  * Metalsmith plugin that adds `collections` of files to the global
  * metadata as a sorted array.
  *
- * @param {Object.<String,CollectionConfig|String>} opts
+ * @param {Object.<string,CollectionConfig|string>} options
  * @return {import('metalsmith').Plugin}
  */
-
-function plugin(opts) {
-  opts = normalize(opts)
-  var keys = Object.keys(opts)
-  var match = matcher(opts)
+function initializeCollections(options) {
+  options = normalizeOptions(options)
+  const collectionNames = Object.keys(options)
+  const mappedCollections = collectionNames.map((name) => {
+    return Object.assign({ name: name }, options[name])
+  })
 
   return function collections(files, metalsmith, done) {
-    var metadata = metalsmith.metadata()
+    const metadata = metalsmith.metadata()
+    const fileNames = Object.keys(files)
 
-    /**
-     * Clear collections (to prevent multiple additions of the same file)
-     */
-
-    keys.forEach(function(key) {
-      metadata[key] = []
-    })
-
-    /**
-     * Clear collections (to prevent multiple additions of the same file when running via metalsmith-browser-sync)
-     */
-
-    keys.forEach(function(key) {
-      metadata[key] = []
-    })
-
-    /**
-     * Find the files in each collection.
-     */
-
-    Object.keys(files).forEach(function(file) {
-      var data = files[file]
-
-      data.path = data.path || file
-
-      const matches = match(file, data)
-      if (matches.length) {
-        debug('processing file: %s', file)
-
-        matches.forEach(function(key) {
-          if (key && keys.indexOf(key) < 0) {
-            opts[key] = {}
-            keys.push(key)
-          }
+    metadata.collections = {}
 
-          metadata[key] = metadata[key] || []
-          // Check if the user supplied a filter function. If so, pass the file metadata to it and
-          // only add files that pass the filter test.
-          if (typeof opts[key].filterBy == 'function') {
-            var filterFunc = opts[key].filterBy
-            if (filterFunc(data)) {
-              metadata[key].push(data)
-            }
-          } else {
-            // If no filter function is provided, add every file to the collection.
-            metadata[key].push(data)
+    fileNames.forEach((filePath) => {
+      // add path property to file metadata for convenience
+      // this is for backward-compatibility only and is pretty useless
+      const file = files[filePath]
+      file.path = file.path || filePath
+
+      // dynamically add collections with default options when encountered in file metadata,
+      // and not explicitly defined in plugin options
+      if (file.collection) {
+        ;(Array.isArray(file.collection) ? file.collection : [file.collection]).forEach((name) => {
+          if (!collectionNames.includes(name)) {
+            collectionNames.push(name)
+            const normalized = Object.assign({}, defaultOptions)
+            mappedCollections.push(Object.assign({ name }, normalized))
           }
         })
       }
     })
 
-    /**
-     * Ensure that a default empty collection exists.
-     */
-
-    keys.forEach(function(key) {
-      metadata[key] = metadata[key] || []
-    })
-
-    /**
-     * Sort the collections.
-     */
-
-    keys.forEach(function(key) {
-      debug('sorting collection: %s', key)
-      var settings = opts[key]
-      var sort = settings.sortBy || 'date'
-      var col = metadata[key]
-
-      if ('function' == typeof sort) {
-        col.sort(sort)
-      } else {
-        col.sort(function(a, b) {
-          a = a[sort]
-          b = b[sort]
-          if (!a && !b) return 0
-          if (!a) return -1
-          if (!b) return 1
-          if (b > a) return -1
-          if (a > b) return 1
-          return 0
-        })
+    debug('Identified %s collections: %s', mappedCollections.length, collectionNames.join())
+
+    mappedCollections.forEach((collection) => {
+      const { pattern, filterBy, sortBy, reverse, refer, limit } = collection
+      const name = collection.name
+      const matches = []
+      debug('Processing collection %s with options %s:', name, collection)
+
+      // first match by pattern if provided
+      if (pattern) {
+        matches.push.apply(
+          matches,
+          metalsmith.match(pattern, fileNames).map((filepath) => {
+            const data = files[filepath]
+            // pattern-matched files might or might not have a "collection" property defined in front-matter
+            // and might also be included in multiple collections
+            if (!data.collection) {
+              data.collection = []
+            } else if (typeof data.collection === 'string') {
+              data.collection = [data.collection]
+            }
+            if (!data.collection.includes(collection.name)) {
+              data.collection = [...data.collection, collection.name]
+            }
+            return data
+          })
+        )
       }
 
-      if (settings.reverse) col.reverse()
-    })
+      // next match by "collection" key, but only push if the files haven't been added through pattern matching first
+      matches.push.apply(
+        matches,
+        Object.values(files).filter((file) => {
+          const patternMatched = matches.includes(file)
+          const isInCollection = Array.isArray(file.collection)
+            ? file.collection.includes(collection.name)
+            : file.collection === collection.name
+          return !patternMatched && isInCollection
+        })
+      )
 
-    /**
-     * Add `next` and `previous` references and apply the `limit` option
-     */
-
-    keys.forEach(function(key) {
-      debug('referencing collection: %s', key)
-      var settings = opts[key]
-      var col = metadata[key]
-      var last = col.length - 1
-      if (opts[key].limit && opts[key].limit < col.length) {
-        col = metadata[key] = col.slice(0, opts[key].limit)
-        last = opts[key].limit - 1
+      if (Object.prototype.hasOwnProperty.call(metadata, name)) {
+        debug('Warning: overwriting previously set metadata property %s', name)
       }
-      if (settings.refer === false) return
-      col.forEach(function(file, i) {
-        if (0 != i) file.previous = col[i - 1]
-        if (last != i) file.next = col[i + 1]
-      })
-    })
-
-    /**
-     * Add collection metadata
-     */
-
-    keys.forEach(function(key) {
-      debug('adding metadata: %s', key)
-      var settings = opts[key]
-      var col = metadata[key]
-      col.metadata = typeof settings.metadata === 'string' ? loadMetadata(settings.metadata) : settings.metadata
-    })
-
-    /**
-     * Add them grouped together to the global metadata.
-     */
+      // apply sort, reverse, filter, limit options in this order
+      metadata[name] = matches.sort(sortBy)
 
-    metadata.collections = {}
-    keys.forEach(function(key) {
-      return (metadata.collections[key] = metadata[key])
-    })
-
-    done()
-  }
-}
-
-/**
- * Normalize an `options` dictionary.
- *
- * @param {Object.<string,CollectionConfig>} options
- */
-
-function normalize(options) {
-  options = options || {}
-
-  for (var key in options) {
-    var val = options[key]
-    if ('string' == typeof val) options[key] = { pattern: val }
-    if (val instanceof Array) options[key] = { pattern: val }
-  }
-
-  return options
-}
-
-/**
- * Generate a matching function for a given set of `collections`.
- *
- * @param {Object.<String, CollectionConfig>} collections
- * @return {Function}
- */
-
-function matcher(cols) {
-  var keys = Object.keys(cols)
-  var matchers = {}
-
-  keys.forEach(function(key) {
-    var opts = cols[key]
-    if (!opts.pattern) {
-      return
-    }
-    matchers[key] = {
-      match: function(file) {
-        return multimatch(file, opts.pattern)
+      if (reverse) {
+        metadata[name].reverse()
       }
-    }
-  })
 
-  return function(file, data) {
-    var matches = []
+      metadata[name] = metadata[name].filter(filterBy).slice(0, limit)
 
-    if (data.collection) {
-      var collection = data.collection
-      if (!Array.isArray(collection)) {
-        collection = [collection]
+      if (collection.metadata) {
+        metadata[name].metadata = collection.metadata
       }
-      collection.forEach(function(key) {
-        matches.push(key)
-
-        if (key && keys.indexOf(key) < 0) {
-          debug('adding new collection through metadata: %s', key)
+      if (refer) {
+        if (reverse) {
+          metadata[name].forEach((file, i) => {
+            Object.assign(file, {
+              next: i > 0 ? metadata[name][i - 1] : null,
+              previous: i < metadata[name].length - 1 ? metadata[name][i + 1] : null
+            })
+          })
+        } else {
+          metadata[name].forEach((file, i) => {
+            Object.assign(file, {
+              previous: i > 0 ? metadata[name][i - 1] : null,
+              next: i < metadata[name].length - 1 ? metadata[name][i + 1] : null
+            })
+          })
         }
-      })
-    }
-
-    for (var key in matchers) {
-      var m = matchers[key]
-      if (m.match(file).length) {
-        matches.push(key)
       }
-    }
 
-    data.collection = unique(matches)
-    return data.collection
+      metadata.collections[name] = metadata[name]
+      debug('Added %s files to collection %s', metadata[name].length, name)
+    })
+    done()
   }
 }
+
+initializeCollections.defaults = defaultOptions
+
+module.exports = initializeCollections

package/package.json

@@ -15,27 +15,25 @@
     "type": "git",
     "url": "https://github.com/metalsmith/collections.git"
   },
-  "version": "1.1.0",
+  "version": "1.2.2",
   "license": "MIT",
   "main": "lib/index.js",
   "dependencies": {
-    "debug": "^4.3.3",
-    "extend": "^3.0.0",
-    "multimatch": "^4.0.0",
-    "read-metadata": "^1.0.0",
-    "uniq": "^1.0.1"
+    "lodash.get": "^4.4.2",
+    "read-metadata": "^1.0.0"
   },
   "devDependencies": {
-    "auto-changelog": "^2.3.0",
+    "auto-changelog": "^2.4.0",
     "coveralls": "^3.1.1",
-    "eslint": "^8.4.1",
-    "eslint-config-prettier": "^8.3.0",
-    "metalsmith": "^2.3.0",
-    "mocha": "^7.2.0",
-    "nodemon": "^1.18.4",
+    "debug": "^4.3.4",
+    "eslint": "^8.20.0",
+    "eslint-config-prettier": "^8.5.0",
+    "metalsmith": "^2.4.1",
+    "mocha": "^9.2.2",
+    "nodemon": "^2.0.19",
     "nyc": "^15.1.0",
-    "prettier": "^1.19.1",
-    "release-it": "^14.11.8"
+    "prettier": "^2.7.1",
+    "release-it": "^15.2.0"
   },
   "directories": {
     "lib": "lib",
@@ -50,7 +48,9 @@
     "coverage": "nyc report --reporter=text-lcov > ./coverage.info",
     "coveralls": "npm run coverage && cat ./coverage.info | coveralls",
     "format": "prettier --write \"**/*.{yml,md,js,json}\"",
-    "lint": "eslint --cache --fix-dry-run .",
+    "format:check": "prettier --list-different \"**/*.{yml,md,js,json}\"",
+    "lint": "eslint --fix .",
+    "lint:check": "eslint --fix-dry-run .",
     "dev": "nodemon --exec 'npm test'",
     "release": "release-it ."
   },
@@ -58,9 +58,9 @@
     "access": "public"
   },
   "peerDependencies": {
-    "metalsmith": "^2.3.0"
+    "metalsmith": "^2.4.1"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=12"
   }
 }