Socket
Socket
Sign inDemoInstall

@rollup/pluginutils

Package Overview
Dependencies
19
Maintainers
4
Versions
24
Alerts
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@rollup/pluginutils

A set of utility functions commonly used by Rollup plugins


Version published
Maintainers
4
Weekly downloads
13,812,266
decreased by-6.16%

Weekly downloads

Package description

What is @rollup/pluginutils?

The @rollup/pluginutils package provides a suite of utility functions commonly used by Rollup plugins. These utilities help with tasks such as filtering files to be included in the bundle, creating minimatch instances, and handling module IDs.

What are @rollup/pluginutils's main functionalities?

createFilter

createFilter allows you to create a filter function that can be used to determine whether a file should be included or excluded based on the provided include and exclude patterns.

import { createFilter } from '@rollup/pluginutils';
const filter = createFilter(include, exclude);
if (filter(somePath)) {
  // Handle the file
}

dataToEsm

dataToEsm converts a JSON object to an ES module string, which can be useful for injecting configuration or other data into your bundle.

import { dataToEsm } from '@rollup/pluginutils';
const data = { foo: 'bar' };
const esModule = dataToEsm(data);
// esModule is now a string of ESM code representing the data

addExtension

addExtension ensures that a file path has the specified extension. If it already has the extension, it returns the path unchanged.

import { addExtension } from '@rollup/pluginutils';
const filename = addExtension('myfile', '.js');
// filename is now 'myfile.js'

Other packages similar to @rollup/pluginutils

Readme

Source

npm size libera manifesto

@rollup/pluginutils

A set of utility functions commonly used by 🍣 Rollup plugins.

Requirements

The plugin utils require an LTS Node version (v14.0.0+) and Rollup v1.20.0+.

Install

Using npm:

npm install @rollup/pluginutils --save-dev

Usage

import utils from '@rollup/pluginutils';
//...

API

Available utility functions are listed below:

Note: Parameter names immediately followed by a ? indicate that the parameter is optional.

addExtension

Adds an extension to a module ID if one does not exist.

Parameters: (filename: String, ext?: String)
Returns: String

import { addExtension } from '@rollup/pluginutils';

export default function myPlugin(options = {}) {
  return {
    resolveId(code, id) {
      // only adds an extension if there isn't one already
      id = addExtension(id); // `foo` -> `foo.js`, `foo.js` -> `foo.js`
      id = addExtension(id, '.myext'); // `foo` -> `foo.myext`, `foo.js` -> `foo.js`
    }
  };
}

attachScopes

Attaches Scope objects to the relevant nodes of an AST. Each Scope object has a scope.contains(name) method that returns true if a given name is defined in the current scope or a parent scope.

Parameters: (ast: Node, propertyName?: String)
Returns: Object

See rollup-plugin-inject or rollup-plugin-commonjs for an example of usage.

import { attachScopes } from '@rollup/pluginutils';
import { walk } from 'estree-walker';

export default function myPlugin(options = {}) {
  return {
    transform(code) {
      const ast = this.parse(code);

      let scope = attachScopes(ast, 'scope');

      walk(ast, {
        enter(node) {
          if (node.scope) scope = node.scope;

          if (!scope.contains('foo')) {
            // `foo` is not defined, so if we encounter it,
            // we assume it's a global
          }
        },
        leave(node) {
          if (node.scope) scope = scope.parent;
        }
      });
    }
  };
}

createFilter

Constructs a filter function which can be used to determine whether or not certain modules should be operated upon.

Parameters: (include?: <picomatch>, exclude?: <picomatch>, options?: Object)
Returns: (id: string | unknown) => boolean

include and exclude

Type: String | RegExp | Array[...String|RegExp]

A valid picomatch pattern, or array of patterns. If options.include is omitted or has zero length, filter will return true by default. Otherwise, an ID must match one or more of the picomatch patterns, and must not match any of the options.exclude patterns.

Note that picomatch patterns are very similar to minimatch patterns, and in most use cases, they are interchangeable. If you have more specific pattern matching needs, you can view this comparison table to learn more about where the libraries differ.

options
resolve

Type: String | Boolean | null

Optionally resolves the patterns against a directory other than process.cwd(). If a String is specified, then the value will be used as the base directory. Relative paths will be resolved against process.cwd() first. If false, then the patterns will not be resolved against any directory. This can be useful if you want to create a filter for virtual module names.

Usage
import { createFilter } from '@rollup/pluginutils';

export default function myPlugin(options = {}) {
  // assume that the myPlugin accepts options of `options.include` and `options.exclude`
  var filter = createFilter(options.include, options.exclude, {
    resolve: '/my/base/dir'
  });

  return {
    transform(code, id) {
      if (!filter(id)) return;

      // proceed with the transformation...
    }
  };
}

dataToEsm

Transforms objects into tree-shakable ES Module imports.

Parameters: (data: Object, options: DataToEsmOptions)
Returns: String

data

Type: Object

An object to transform into an ES module.

options

Type: DataToEsmOptions

Note: Please see the TypeScript definition for complete documentation of these options

Usage
import { dataToEsm } from '@rollup/pluginutils';

const esModuleSource = dataToEsm(
  {
    custom: 'data',
    to: ['treeshake']
  },
  {
    compact: false,
    indent: '\t',
    preferConst: true,
    objectShorthand: true,
    namedExports: true,
    includeArbitraryNames: false
  }
);
/*
Outputs the string ES module source:
  export const custom = 'data';
  export const to = ['treeshake'];
  export default { custom, to };
*/

extractAssignedNames

Extracts the names of all assignment targets based upon specified patterns.

Parameters: (param: Node)
Returns: Array[...String]

param

Type: Node

An acorn AST Node.

Usage
import { extractAssignedNames } from '@rollup/pluginutils';
import { walk } from 'estree-walker';

export default function myPlugin(options = {}) {
  return {
    transform(code) {
      const ast = this.parse(code);

      walk(ast, {
        enter(node) {
          if (node.type === 'VariableDeclarator') {
            const declaredNames = extractAssignedNames(node.id);
            // do something with the declared names
            // e.g. for `const {x, y: z} = ...` => declaredNames = ['x', 'z']
          }
        }
      });
    }
  };
}

makeLegalIdentifier

Constructs a bundle-safe identifier from a String.

Parameters: (str: String)
Returns: String

Usage
import { makeLegalIdentifier } from '@rollup/pluginutils';

makeLegalIdentifier('foo-bar'); // 'foo_bar'
makeLegalIdentifier('typeof'); // '_typeof'

normalizePath

Converts path separators to forward slash.

Parameters: (filename: String)
Returns: String

Usage
import { normalizePath } from '@rollup/pluginutils';

normalizePath('foo\\bar'); // 'foo/bar'
normalizePath('foo/bar'); // 'foo/bar'

Meta

CONTRIBUTING

LICENSE (MIT)

Keywords

FAQs

Last updated on 28 Nov 2023

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

Related posts

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.


  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc