Class Plugin

constructor

• new Plugin(): MatterJS.Plugin

  Returns MatterJS.Plugin

Optionalfor

install

name

version

Staticdependencies

• dependencies(
      module: MatterJS.Dependency,
      tracked?: { [_: string]: string[] },
  ): string | { [_: string]: string[] }

  Recursively finds all of a module's dependencies and returns a flat dependency graph.

  Parameters

  • module: MatterJS.Dependency

    {} The module.
  • Optionaltracked: { [_: string]: string[] }

  Returns string | { [_: string]: string[] }

  A dependency graph.

  Method

  dependencies

StaticdependencyParse

• dependencyParse(
      dependency: MatterJS.Dependency,
  ): { name: string; range: string }

  Parses a dependency string into its components. The dependency is a string of the format 'module-name' or 'module-name@version'. See documentation for Plugin.versionParse for a description of the format. This function can also handle dependencies that are already resolved (e.g. a module object).

  Parameters

  • dependency: MatterJS.Dependency

    {string} The dependency of the format 'module-name' or 'module-name@version'.

  Returns { name: string; range: string }

  The dependency parsed into its components.

  Method

  dependencyParse

StaticisFor

• isFor(
      plugin: MatterJS.Plugin,
      module: { name?: string; [_: string]: any },
  ): boolean

  Returns true if plugin.for is applicable to module by comparing against module.name and module.version. If plugin.for is not specified then it is assumed to be applicable. The value of plugin.for is a string of the format 'module-name' or 'module-name@version'.

  Parameters

  • plugin: MatterJS.Plugin

    {} The plugin.
  • module: { name?: string; [_: string]: any }

    {} The module.

  Returns boolean

  true if plugin.for is applicable to module, otherwise false.

  Method

  isFor

StaticisPlugin

• isPlugin(obj: {}): boolean

  Returns true if the object meets the minimum standard to be considered a plugin. This means it must define the following properties:

  • name
  • version
  • install

  Parameters

  • obj: {}

    {} The obj to test.

  Returns boolean

  true if the object can be considered a plugin otherwise false.

  Method

  isPlugin

Staticregister

• register(plugin: MatterJS.Plugin): MatterJS.Plugin

  Registers a plugin object so it can be resolved later by name.

  Parameters

  • plugin: MatterJS.Plugin

    {} The plugin to register.

  Returns MatterJS.Plugin

  The plugin.

  Method

  register

Staticresolve

• resolve(dependency: string): MatterJS.Plugin

  Resolves a dependency to a plugin object from the registry if it exists. The dependency may contain a version, but only the name matters when resolving.

  Parameters

  • dependency: string

    {string} The dependency.

  Returns MatterJS.Plugin

  The plugin if resolved, otherwise undefined.

  Method

  resolve

StatictoString

• toString(plugin: string | MatterJS.Plugin): string

  Returns a pretty printed plugin name and version.

  Parameters

  • plugin: string | MatterJS.Plugin

    {} The plugin.

  Returns string

  Pretty printed plugin name and version.

  Method

  toString

Staticuse

• use(
      module: { uses?: (string | MatterJS.Plugin)[]; [_: string]: any },
      plugins?: (string | MatterJS.Plugin)[],
  ): void

  Installs the plugins by calling plugin.install on each plugin specified in plugins if passed, otherwise module.uses. For installing plugins on Matter see the convenience function Matter.use. Plugins may be specified either by their name or a reference to the plugin object. Plugins themselves may specify further dependencies, but each plugin is installed only once. Order is important, a topological sort is performed to find the best resulting order of installation. This sorting attempts to satisfy every dependency's requested ordering, but may not be exact in all cases. This function logs the resulting status of each dependency in the console, along with any warnings.

  • A green tick ✅ indicates a dependency was resolved and installed.
  • An orange diamond 🔶 indicates a dependency was resolved but a warning was thrown for it or one if its dependencies.
  • A red cross ❌ indicates a dependency could not be resolved. Avoid calling this function multiple times on the same module unless you intend to manually control installation order.

  Parameters

  • module: { uses?: (string | MatterJS.Plugin)[]; [_: string]: any }

    {} The module install plugins on.
  • Optionalplugins: (string | MatterJS.Plugin)[]

    {} The plugins to install on module (optional, defaults to module.uses).

  Returns void

  Method

  use

StaticversionParse

• versionParse(
      range: string,
  ): {
      isRange: boolean;
      number: number;
      operator: string;
      parts: number[];
      prerelease: string;
      range: string;
      version: string;
  }

  Parses a version string into its components. Versions are strictly of the format x.y.z (as in semver). Versions may optionally have a prerelease tag in the format x.y.z-alpha. Ranges are a strict subset of npm ranges. Only the following range types are supported:

  • Tilde ranges e.g. ~1.2.3
  • Caret ranges e.g. ^1.2.3
  • Exact version e.g. 1.2.3
  • Any version *

  Parameters

  • range: string

    {string} The version string.

  Returns {
      isRange: boolean;
      number: number;
      operator: string;
      parts: number[];
      prerelease: string;
      range: string;
      version: string;
  }

  The version range parsed into its components.

  Method

  versionParse

StaticversionSatisfies

• versionSatisfies(version: string, range: string): boolean

  Returns true if version satisfies the given range. See documentation for Plugin.versionParse for a description of the format. If a version or range is not specified, then any version (*) is assumed to satisfy.

  Parameters

  • version: string

    {string} The version string.
  • range: string

    {string} The range string.

  Returns boolean

  true if version satisfies range, otherwise false.

  Method

  versionSatisfies