find-plugins
    TypeScript icon, indicating that this package has built-in type declarations

    1.1.7 • Public • Published

    Travis Dependencies npm downloads latest version

    find-plugins

    A simple tool to find installed npm packages that meet certain criteria. Great for finding installed plugins or complementary packages to yours.

    Usage

    Simple

    // Looks up the package.json in process.cwd, and returns any dependencies
    // listed that have your package's `name` in their keywords.
    plugins = findPlugins();

    Custom Keyword

    // Same as above, but rather than using your package.json name as the keyword
    // to search for, it will look for dependencies with "plugin" in their keyword
    // list.
    plugins = findPlugins({
        keyword: 'plugin'
    });

    Custom Filter

    // This time, the supplied filter function will be called for each dependency,
    // and only those that return true will be returned in the final array.
    //
    // The filter function is supplied the package.json of the dependency to check.
    // In this case, this will find all dependencies whose name starts with
    // "my-plugin-"
    plugins = findPlugins({
        filter: function(pkg) {
            return /^my-plugin-/.test(pkg.name);
        }
    });

    Ignore package.json dependency list

    // The scanAllDirs option allows you to skip loading your app's package.json
    // dependency list. Instead, it will scan all directories in the node_modules
    // folder, regardless of whether they are listed as dependencies or not.
    plugins = findPlugins({
        scanAllDirs: true
    });

    Specify node_modules directory and your package.json

    // Got an unusual setup? Just pass in the path of the directory containing your
    // dependencies, and the path to your app's package.json file. `pkg` is
    // optional if you are using `scanAllDirs` and `keyword` or `filter`.
    plugins = findPlugins({
        dir: path.join('..', 'foo', 'bar', 'node_modules'),
        pkg: path.join('..', 'foo', 'bar', 'package.json')
    });

    Sort the plugins based on "before" and "after" config in their package.json's

    // Each plugin can optionally include a "plugin-config" (or whatever you pass in under `configName`)
    // with a "before" and/or "after" property. These can be the name of another plugin (or an array of
    // other plugin names) that this plugin should come before/after. The returned array will be sorted
    // according to these rules via a directed acyclic graph
    plugins = findPlugins({
        sort: true,
        configName: 'plugin-config'
    });

    Options

    {
     
      /**
       * The node_modules directory to scan for plugins
       *
       * @type {string} 
       */
      dir?: string = process.cwd(),
     
      /**
       * The path to the package.json that lists dependencies to check for plugins
       *
       * @type {string} 
       */
      pkg?: string = './package.json',
     
      /**
       * An array of additional paths to check as plugins
       *
       * @type {string[]} 
       */
      include?: string[] = [],
     
      /**
       * If supplied, a package will be considered a plugin if `keyword` is present in it's package.json
       * "keywords" array
       *
       * @type {string} 
       */
      keyword?: string = pkg.name,
     
      /**
       * If sort: true is supplied, this determines what property of the plugin's package.json to check
       * for the sort configuration (it should be an object with "before" and "after" properties which
       * are arrays of other plugins names)
       *
       * @type {boolean} 
       */
      sort?: boolean = false,
     
      /**
       * The property on a plugin's package.json that contains sort config (an object with "before"
       * and/or "after" properties, which are the names of the plugin, or arrays of names)
       *
       * @type {string} 
       */
      configName?: string = pkg.name,
     
      /**
       * A custom filter function that will receive the package summary and should return a boolean
       * indicating whether or not that package is a plugin.
       *
       * @type {function} 
       */
      filter?: (plugin: PluginSummary) => boolean,
     
      /**
       * If true, the package.json list of dependencies will be ignored, and all packages found in
       * dir will be checked.
       *
       * @type {boolean} 
       */
      scanAllDirs?: boolean,
     
      /**
       * By default, findPlugins checks only the packages listed under "dependencies" in the
       * package.json. Setting this option to true will ignore those packages listed under
       * "dependencies".
       *
       * @type {boolean} 
       */
      excludeDependencies?: boolean,
     
      /**
       * Also check packages listed under devDependencies
       *
       * @type {boolean} 
       */
      includeDev?: boolean,
     
      /**
       * Also check packages listed under peerDependencies
       *
       * @type {boolean} 
       */
      includePeer?: boolean,
     
      /**
       * Also check packages listed under bundleDependencies
       *
       * @type {boolean} 
       */
      includeBundle?: boolean,
     
      /**
       * Also check packages listed under optionalDependencies
       *
       * @type {boolean} 
       */
      includeOptional?: boolean
     
    }

    Returns

    > findPlugins();
    [
        {
            dir: './node_modules/foobar',
            pkg: { name: 'foobar', version: '0.0.1', ... }
        },
        ...
    ]

    Install

    npm i find-plugins

    DownloadsWeekly Downloads

    2,383

    Version

    1.1.7

    License

    MIT

    Unpacked Size

    52.5 kB

    Total Files

    11

    Last publish

    Collaborators

    • avatar