@d-es-ign/stryker-js-core 9.6.0

package/src/config/options-validator.ts

@@ -0,0 +1,317 @@
+import os from 'os';
+import path from 'path';
+
+import { Minimatch } from 'minimatch';
+import ajvModule, { ValidateFunction } from 'ajv';
+import { StrykerOptions, strykerCoreSchema } from '@stryker-mutator/api/core';
+import { tokens, commonTokens } from '@stryker-mutator/api/plugin';
+import {
+  noopLogger,
+  findUnserializables,
+  Immutable,
+  deepFreeze,
+} from '@stryker-mutator/util';
+import { Logger } from '@stryker-mutator/api/logging';
+import type { JSONSchema7 } from 'json-schema';
+
+import { coreTokens } from '../di/index.js';
+import { ConfigError } from '../errors.js';
+import { objectUtils, optionsPath } from '../utils/index.js';
+import { CommandTestRunner } from '../test-runner/command-test-runner.js';
+import { IGNORE_PATTERN_CHARACTER, MUTATION_RANGE_REGEX } from '../fs/index.js';
+
+import { describeErrors } from './validation-errors.js';
+
+const Ajv = ajvModule.default;
+
+const ajv = new Ajv({
+  useDefaults: true,
+  allErrors: true,
+  jsPropertySyntax: true,
+  verbose: true,
+  logger: false,
+  strict: false,
+});
+
+export class OptionsValidator {
+  private readonly validateFn: ValidateFunction;
+
+  public static readonly inject = tokens(
+    coreTokens.validationSchema,
+    commonTokens.logger,
+  );
+
+  constructor(
+    private readonly schema: JSONSchema7,
+    private readonly log: Logger,
+  ) {
+    this.validateFn = ajv.compile(schema);
+  }
+
+  /**
+   * Validates the provided options, throwing an error if something is wrong.
+   * Optionally also warns about excess or unserializable options.
+   * @param options The stryker options to validate
+   * @param mark Wether or not to log warnings on unknown properties or unserializable properties
+   */
+  public validate(
+    options: Record<string, unknown>,
+    mark = false,
+  ): asserts options is StrykerOptions {
+    this.removeDeprecatedOptions(options);
+    this.schemaValidate(options);
+    this.customValidation(options);
+    if (mark) {
+      this.markOptions(options);
+    }
+  }
+
+  private removeDeprecatedOptions(rawOptions: Record<string, unknown>) {
+    if (typeof rawOptions.mutator === 'string') {
+      this.log.warn(
+        'DEPRECATED. Use of "mutator" as string is no longer needed. You can remove it from your configuration. Stryker now supports mutating of JavaScript and friend files out of the box.',
+      );
+      delete rawOptions.mutator;
+    }
+    // @ts-expect-error mutator.name
+    if (typeof rawOptions.mutator === 'object' && rawOptions.mutator.name) {
+      this.log.warn(
+        'DEPRECATED. Use of "mutator.name" is no longer needed. You can remove "mutator.name" from your configuration. Stryker now supports mutating of JavaScript and friend files out of the box.',
+      );
+      // @ts-expect-error mutator.name
+      delete rawOptions.mutator.name;
+    }
+    if (Object.keys(rawOptions).includes('testFramework')) {
+      this.log.warn(
+        'DEPRECATED. Use of "testFramework" is no longer needed. You can remove it from your configuration. Your test runner plugin now handles its own test framework integration.',
+      );
+      delete rawOptions.testFramework;
+    }
+    if (Array.isArray(rawOptions.transpilers)) {
+      const example = rawOptions.transpilers.includes('babel')
+        ? 'babel src --out-dir lib'
+        : rawOptions.transpilers.includes('typescript')
+          ? 'tsc -b'
+          : rawOptions.transpilers.includes('webpack')
+            ? 'webpack --config webpack.config.js'
+            : 'npm run build';
+      this.log.warn(
+        `DEPRECATED. Support for "transpilers" is removed. You can now configure your own "${optionsPath('buildCommand')}". For example, ${example}.`,
+      );
+      delete rawOptions.transpilers;
+    }
+    if (Array.isArray(rawOptions.files)) {
+      const ignorePatternsName = optionsPath('ignorePatterns');
+      const isString = (uncertain: unknown): uncertain is string =>
+        typeof uncertain === 'string';
+      const files = rawOptions.files.filter(isString);
+      const newIgnorePatterns: string[] = [
+        '**',
+        ...files.map((filePattern) =>
+          filePattern.startsWith(IGNORE_PATTERN_CHARACTER)
+            ? filePattern.substr(1)
+            : `${IGNORE_PATTERN_CHARACTER}${filePattern}`,
+        ),
+      ];
+      delete rawOptions.files;
+      this.log.warn(
+        `DEPRECATED. Use of "files" is deprecated, please use "${ignorePatternsName}" instead (or remove "files" altogether will probably work as well). For now, rewriting them as ${JSON.stringify(
+          newIgnorePatterns,
+        )}. See https://stryker-mutator.io/docs/stryker-js/configuration/#ignorepatterns-string`,
+      );
+      const existingIgnorePatterns = Array.isArray(
+        rawOptions[ignorePatternsName],
+      )
+        ? (rawOptions[ignorePatternsName] as unknown[])
+        : [];
+      rawOptions[ignorePatternsName] = [
+        ...newIgnorePatterns,
+        ...existingIgnorePatterns,
+      ];
+    }
+    // @ts-expect-error jest.enableBail
+    if (rawOptions.jest?.enableBail !== undefined) {
+      this.log.warn(
+        'DEPRECATED. Use of "jest.enableBail" is deprecated, please use "disableBail" instead. See https://stryker-mutator.io/docs/stryker-js/configuration#disablebail-boolean',
+      );
+      // @ts-expect-error jest.enableBail
+      rawOptions.disableBail = !rawOptions.jest?.enableBail;
+      // @ts-expect-error jest.enableBail
+      delete rawOptions.jest.enableBail;
+    }
+
+    // @ts-expect-error htmlReporter.baseDir
+    if (rawOptions.htmlReporter?.baseDir) {
+      this.log.warn(
+        `DEPRECATED. Use of "htmlReporter.baseDir" is deprecated, please use "${optionsPath(
+          'htmlReporter',
+          'fileName',
+        )}" instead. See https://stryker-mutator.io/docs/stryker-js/configuration/#reporters-string`,
+      );
+      // @ts-expect-error htmlReporter.baseDir
+      if (!rawOptions.htmlReporter.fileName) {
+        // @ts-expect-error htmlReporter.fileName
+        rawOptions.htmlReporter.fileName = path.join(
+          // @ts-expect-error htmlReporter.baseDir
+          String(rawOptions.htmlReporter.baseDir),
+          'index.html',
+        );
+      }
+      // @ts-expect-error htmlReporter.baseDir
+      delete rawOptions.htmlReporter.baseDir;
+    }
+  }
+
+  private customValidation(options: StrykerOptions) {
+    const additionalErrors: string[] = [];
+    if (options.thresholds.high < options.thresholds.low) {
+      additionalErrors.push(
+        'Config option "thresholds.high" should be higher than "thresholds.low".',
+      );
+    }
+    if (options.maxConcurrentTestRunners !== Number.MAX_SAFE_INTEGER) {
+      this.log.warn(
+        'DEPRECATED. Use of "maxConcurrentTestRunners" is deprecated. Please use "concurrency" instead.',
+      );
+      if (
+        !options.concurrency &&
+        options.maxConcurrentTestRunners < os.availableParallelism() - 1
+      ) {
+        options.concurrency = options.maxConcurrentTestRunners;
+      }
+    }
+    if (CommandTestRunner.is(options.testRunner)) {
+      if (options.testRunnerNodeArgs.length) {
+        this.log.warn(
+          'Using "testRunnerNodeArgs" together with the "command" test runner is not supported, these arguments will be ignored. You can add your custom arguments by setting the "commandRunner.command" option.',
+        );
+      }
+    }
+    if (options.ignoreStatic && options.coverageAnalysis !== 'perTest') {
+      additionalErrors.push(
+        `Config option "${optionsPath('ignoreStatic')}" is not supported with coverage analysis "${
+          options.coverageAnalysis
+        }". Either turn off "${optionsPath('ignoreStatic')}", or configure "${optionsPath('coverageAnalysis')}" to be "perTest".`,
+      );
+    }
+    options.mutate.forEach((mutateString, index) => {
+      const match = MUTATION_RANGE_REGEX.exec(mutateString);
+      if (match) {
+        if (new Minimatch(mutateString).hasMagic()) {
+          additionalErrors.push(
+            `Config option "mutate[${index}]" is invalid. Cannot combine a glob expression with a mutation range in "${mutateString}".`,
+          );
+        } else {
+          const [
+            _,
+            _fileName,
+            mutationRange,
+            startLine,
+            _startColumn,
+            endLine,
+            _endColumn,
+          ] = match;
+          const start = parseInt(startLine, 10);
+          const end = parseInt(endLine, 10);
+          if (start < 1) {
+            additionalErrors.push(
+              `Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid, line ${start} does not exist (lines start at 1).`,
+            );
+          }
+          if (start > end) {
+            additionalErrors.push(
+              `Config option "mutate[${index}]" is invalid. Mutation range "${mutationRange}" is invalid. The "from" line number (${start}) should be less then the "to" line number (${end}).`,
+            );
+          }
+        }
+      }
+    });
+
+    additionalErrors.forEach((error) => this.log.error(error));
+    this.throwErrorIfNeeded(additionalErrors);
+  }
+
+  private schemaValidate(options: unknown): asserts options is StrykerOptions {
+    if (!this.validateFn(options)) {
+      const describedErrors = describeErrors(this.validateFn.errors!);
+      describedErrors.forEach((error) => this.log.error(error));
+      this.throwErrorIfNeeded(describedErrors);
+    }
+  }
+
+  private throwErrorIfNeeded(errors: string[]) {
+    if (errors.length > 0) {
+      throw new ConfigError(
+        errors.length === 1
+          ? 'Please correct this configuration error and try again.'
+          : 'Please correct these configuration errors and try again.',
+      );
+    }
+  }
+
+  private markOptions(options: StrykerOptions): void {
+    this.markExcessOptions(options);
+    this.markUnserializableOptions(options);
+  }
+
+  private markExcessOptions(options: StrykerOptions) {
+    const OPTIONS_ADDED_BY_STRYKER = ['set', 'configFile', '$schema'];
+
+    if (objectUtils.isWarningEnabled('unknownOptions', options.warnings)) {
+      const schemaKeys = Object.keys(this.schema.properties!);
+      const excessPropertyNames = Object.keys(options)
+        .filter((key) => !key.endsWith('_comment'))
+        .filter((key) => !OPTIONS_ADDED_BY_STRYKER.includes(key))
+        .filter((key) => !schemaKeys.includes(key));
+
+      if (excessPropertyNames.length) {
+        excessPropertyNames.forEach((excessPropertyName) => {
+          this.log.warn(
+            `Unknown stryker config option "${excessPropertyName}".`,
+          );
+        });
+
+        this.log.warn(`Possible causes:
+     * Is it a typo on your end?
+     * Did you only write this property as a comment? If so, please postfix it with "_comment".
+     * You might be missing a plugin that is supposed to use it. Stryker loaded plugins from: ${JSON.stringify(options.plugins)}
+     * The plugin that is using it did not contribute explicit validation. 
+     (disable "${optionsPath('warnings', 'unknownOptions')}" to ignore this warning)`);
+      }
+    }
+  }
+
+  private markUnserializableOptions(options: StrykerOptions) {
+    if (
+      objectUtils.isWarningEnabled('unserializableOptions', options.warnings)
+    ) {
+      const unserializables = findUnserializables(options);
+      if (unserializables) {
+        unserializables.forEach((unserializable) =>
+          this.log.warn(
+            `Config option "${unserializable.path.join('.')}" is not (fully) serializable. ${
+              unserializable.reason
+            }. Any test runner or checker worker processes might not receive this value as intended.`,
+          ),
+        );
+        this.log.warn(
+          `(disable ${optionsPath('warnings', 'unserializableOptions')} to ignore this warning)`,
+        );
+      }
+    }
+  }
+}
+
+export function createDefaultOptions(): StrykerOptions {
+  const options: Record<string, unknown> = {};
+  const validator: OptionsValidator = new OptionsValidator(
+    strykerCoreSchema,
+    noopLogger,
+  );
+  validator.validate(options);
+  return options;
+}
+
+export const defaultOptions: Immutable<StrykerOptions> = deepFreeze(
+  createDefaultOptions(),
+);

package/src/config/validation-errors.ts

@@ -0,0 +1,192 @@
+import { ErrorObject } from 'ajv';
+
+import groupby from 'lodash.groupby';
+
+/**
+ * Convert AJV errors to human readable messages
+ * @param allErrors The AJV errors to describe
+ */
+export function describeErrors(allErrors: ErrorObject[]): string[] {
+  const processedErrors = filterRelevantErrors(allErrors);
+  return processedErrors.map(describeError);
+}
+
+/**
+ * Filters the relevant AJV errors for error reporting.
+ * Removes meta schema errors, merges type errors for the same `dataPath` and removes type errors for which another error also exist.
+ * @param allErrors The raw source AJV errors
+ * @example
+ * This:
+ *  ```
+ *  [
+ *   {
+ *     keyword: 'type',
+ *     dataPath: '.mutator',
+ *     params: { type: 'string' },
+ *     [...]
+ *   },
+ *   {
+ *     keyword: 'required',
+ *     dataPath: '.mutator',
+ *     params: { missingProperty: 'name' },
+ *     [...]
+ *   },
+ *   {
+ *     keyword: 'oneOf',
+ *     dataPath: '.mutator',
+ *     params: { passingSchemas: null },
+ *     [...]
+ *   }
+ *  ]
+ *  ```
+ *
+ * Becomes:
+ *  ```
+ *  [
+ *   {
+ *    keyword: 'required',
+ *    dataPath: '.mutator',
+ *    params: { missingProperty: 'name' },
+ *    [...]
+ *   }
+ *  ]
+ *  ```
+ */
+function filterRelevantErrors(allErrors: ErrorObject[]): ErrorObject[] {
+  // These are the "meta schema" keywords. A Meta schema is a schema consisting of other schemas. See https://json-schema.org/understanding-json-schema/structuring.html
+  const META_SCHEMA_KEYWORDS = Object.freeze(['anyOf', 'allOf', 'oneOf']);
+
+  // Split the meta errors from what I call "single errors" (the real errors)
+  const [metaErrors, singleErrors] = split(allErrors, (error) =>
+    META_SCHEMA_KEYWORDS.includes(error.keyword),
+  );
+
+  // Filter out the single errors we want to show
+  const nonShadowedSingleErrors = removeShadowingErrors(
+    singleErrors,
+    metaErrors,
+  );
+
+  // We're handling type errors differently, split them out
+  const [typeErrors, nonTypeErrors] = split(
+    nonShadowedSingleErrors,
+    (error) => error.keyword === 'type',
+  );
+
+  // Filter out the type errors that already have other errors as well.
+  // For example when setting `logLevel: 4`, we don't want to see the error specifying that logLevel should be a string,
+  // if the other error already specified that it should be one of the enum values.
+  const nonShadowingTypeErrors = typeErrors.filter(
+    (typeError) =>
+      !nonTypeErrors.some(
+        (nonTypeError) => nonTypeError.instancePath === typeError.instancePath,
+      ),
+  );
+  const typeErrorsMerged = mergeTypeErrorsByPath(nonShadowingTypeErrors);
+  return [...nonTypeErrors, ...typeErrorsMerged];
+}
+
+/**
+ * Remove the single errors that are pointing to the same data path.
+ * This can happen when using meta schemas.
+ * For example, the "mutator" Stryker option can be either a `string` or a `MutatorDescriptor`.
+ * A data object of `{ "foo": "bar" }` would result in 2 errors. One of a missing property "name" missing, and one that mutator itself should be a string.
+ * @param singleErrors The 'real' errors
+ * @param metaErrors The grouping errors
+ */
+function removeShadowingErrors(
+  singleErrors: ErrorObject[],
+  metaErrors: ErrorObject[],
+): ErrorObject[] {
+  return singleErrors.filter((error) => {
+    if (
+      metaErrors.some((metaError) =>
+        error.instancePath.startsWith(metaError.instancePath),
+      )
+    ) {
+      return !singleErrors.some(
+        (otherError) =>
+          otherError.instancePath.startsWith(error.instancePath) &&
+          otherError.instancePath.length > error.instancePath.length,
+      );
+    } else {
+      return true;
+    }
+  });
+}
+
+function split<T>(items: T[], splitFn: (item: T) => boolean): [T[], T[]] {
+  return [items.filter(splitFn), items.filter((error) => !splitFn(error))];
+}
+
+/**
+ * Merge type errors that have the same path into 1.
+ * @example
+ *  The 'plugins' Stryker option can have 2 types, null or an array of strings.
+ *  When setting  `plugins: 'my-plugin'` we get 2 type errors, because it isn't an array AND it isn't `null`.
+ * @param typeErrors The type errors to merge by path
+ */
+function mergeTypeErrorsByPath(typeErrors: ErrorObject[]): ErrorObject[] {
+  const typeErrorsByPath = groupby(typeErrors, (error) => error.instancePath);
+  return Object.values(typeErrorsByPath).map(mergeTypeErrors);
+
+  function mergeTypeErrors(errors: ErrorObject[]): ErrorObject {
+    const params = {
+      type: errors.map((error) => error.params.type).join(','),
+    };
+    return {
+      ...errors[0],
+      params,
+    };
+  }
+}
+
+/**
+ * Converts the AJV error object to a human readable error.
+ * @param error The error to describe
+ */
+function describeError(error: ErrorObject): string {
+  const errorPrefix = `Config option "${error.instancePath.substr(1)}"`;
+
+  switch (error.keyword) {
+    case 'type': {
+      const expectedTypeDescription = error.params.type.split(',').join(' or ');
+      return `${errorPrefix} has the wrong type. It should be a ${expectedTypeDescription}, but was a ${jsonSchemaType(error.data)}.`;
+    }
+    case 'enum':
+      return `${errorPrefix} should be one of the allowed values (${new Intl.ListFormat('en', { type: 'disjunction' }).format((error.params.allowedValues as unknown[]).map(stringify))}), but was ${stringify(
+        error.data,
+      )}.`;
+    case 'minimum':
+    case 'maximum':
+      return `${errorPrefix} ${error.message}, was ${String(error.data)}.`;
+    default:
+      return `${errorPrefix} ${error.message!.replace(/'/g, '"')}`;
+  }
+}
+
+/**
+ * Returns the JSON schema name of the type. JSON schema types are slightly different from actual JS types.
+ * @see https://json-schema.org/understanding-json-schema/reference/type.html
+ * @param value The value of which it's type should be known
+ */
+function jsonSchemaType(value: unknown): string {
+  if (value === null) {
+    return 'null';
+  }
+  if (value === undefined) {
+    return 'undefined';
+  }
+  if (Array.isArray(value)) {
+    return 'array';
+  }
+  return typeof value;
+}
+
+function stringify(value: unknown): string {
+  if (typeof value === 'number' && isNaN(value)) {
+    return 'NaN';
+  } else {
+    return JSON.stringify(value);
+  }
+}

package/src/di/core-tokens.ts

@@ -0,0 +1,39 @@
+export const checkerPool = 'checkerPool';
+export const checkerFactory = 'checkerFactory';
+export const checkerConcurrencyTokens = 'checkerConcurrencyTokens';
+export const disableTypeChecksHelper = 'disableTypeChecksHelper';
+export const execa = 'execa';
+export const execaSync = 'execaSync';
+export const dryRunResult = 'dryRunResult';
+export const mutants = 'mutants';
+export const mutantTestPlanner = 'mutantTestPlanner';
+export const process = 'process';
+export const pluginModulePaths = 'pluginModulePaths';
+export const temporaryDirectory = 'temporaryDirectory';
+export const unexpectedExitRegistry = 'unexpectedExitRegistry';
+export const timer = 'timer';
+export const timeOverheadMS = 'timeOverheadMS';
+export const loggingServerAddress = 'loggingServerAddress';
+export const loggerActiveLevel = 'loggerActiveLevel';
+export const loggerConsoleOut = 'loggerConsoleOut';
+export const loggingSink = 'loggingSink';
+export const loggingServer = 'loggingServer';
+export const mutationTestReportHelper = 'mutationTestReportHelper';
+export const sandbox = 'sandbox';
+export const concurrencyTokenProvider = 'concurrencyTokenProvider';
+export const testRunnerFactory = 'testRunnerFactory';
+export const testRunnerPool = 'testRunnerPool';
+export const testRunnerConcurrencyTokens = 'testRunnerConcurrencyTokens';
+export const reporter = 'reporter';
+export const reporterOverride = 'reporterOverride';
+export const pluginCreator = 'pluginCreator';
+export const pluginsByKind = 'pluginsByKind';
+export const validationSchema = 'validationSchema';
+export const optionsValidator = 'optionsValidator';
+export const requireFromCwd = 'requireFromCwd';
+export const resolveFromCwd = 'resolveFromCwd';
+export const fs = 'fs';
+export const testCoverage = 'testCoverage';
+export const incrementalDiffer = 'incrementalDiffer';
+export const project = 'project';
+export const workerIdGenerator = 'worker-id-generator';

package/src/di/index.ts

@@ -0,0 +1,4 @@
+export * as coreTokens from './core-tokens.js';
+
+export * from './plugin-loader.js';
+export * from './plugin-creator.js';

package/src/di/plugin-creator.ts

@@ -0,0 +1,102 @@
+import {
+  Plugins,
+  PluginInterfaces,
+  PluginContext,
+  Injector,
+  Plugin,
+  PluginKind,
+  ClassPlugin,
+  FactoryPlugin,
+  InjectionToken,
+  tokens,
+  commonTokens,
+  ValuePlugin,
+} from '@stryker-mutator/api/plugin';
+import { InjectableFunction, InjectableClass } from 'typed-inject';
+
+import { coreTokens } from './index.js';
+
+export class PluginCreator {
+  public static readonly inject = tokens(
+    coreTokens.pluginsByKind,
+    commonTokens.injector,
+  );
+  constructor(
+    private readonly pluginsByKind: Map<PluginKind, Array<Plugin<PluginKind>>>,
+    private readonly injector: Injector<PluginContext>,
+  ) {}
+
+  public create<TPlugin extends keyof Plugins>(
+    kind: TPlugin,
+    name: string,
+  ): PluginInterfaces[TPlugin] {
+    const plugin = this.findPlugin(kind, name);
+    if (isFactoryPlugin(plugin)) {
+      return this.injector.injectFunction(
+        plugin.factory as InjectableFunction<
+          PluginContext,
+          PluginInterfaces[TPlugin],
+          Array<InjectionToken<PluginContext>>
+        >,
+      );
+    } else if (isClassPlugin(plugin)) {
+      return this.injector.injectClass(
+        plugin.injectableClass as InjectableClass<
+          PluginContext,
+          PluginInterfaces[TPlugin],
+          Array<InjectionToken<PluginContext>>
+        >,
+      );
+    } else if (isValuePlugin(plugin)) {
+      return plugin.value;
+    }
+    throw new Error(
+      `Plugin "${kind}:${name}" could not be created, missing "factory", "injectableClass" or "value" property.`,
+    );
+  }
+
+  private findPlugin<T extends keyof Plugins>(
+    kind: T,
+    name: string,
+  ): Plugins[T] {
+    const plugins = this.pluginsByKind.get(kind);
+    if (plugins) {
+      const pluginFound = plugins.find(
+        (plugin) => plugin.name.toLowerCase() === name.toLowerCase(),
+      );
+      if (pluginFound) {
+        return pluginFound as Plugins[T];
+      } else {
+        throw new Error(
+          `Cannot find ${kind} plugin "${name}". Did you forget to install it? Loaded ${kind} plugins were: ${new Intl.ListFormat('en').format(plugins.map((p) => `"${p.name}"`))}`,
+        );
+      }
+    } else {
+      throw new Error(
+        `Cannot find ${kind} plugin "${name}". In fact, no ${kind} plugins were loaded. Did you forget to install it?`,
+      );
+    }
+  }
+}
+
+function isFactoryPlugin(
+  plugin: Plugin<PluginKind>,
+): plugin is FactoryPlugin<PluginKind, Array<InjectionToken<PluginContext>>> {
+  return Boolean(
+    (plugin as FactoryPlugin<PluginKind, Array<InjectionToken<PluginContext>>>)
+      .factory,
+  );
+}
+function isClassPlugin(
+  plugin: Plugin<PluginKind>,
+): plugin is ClassPlugin<PluginKind, Array<InjectionToken<PluginContext>>> {
+  return Boolean(
+    (plugin as ClassPlugin<PluginKind, Array<InjectionToken<PluginContext>>>)
+      .injectableClass,
+  );
+}
+function isValuePlugin(
+  plugin: Plugin<PluginKind>,
+): plugin is ValuePlugin<PluginKind> {
+  return Boolean((plugin as ValuePlugin<PluginKind>).value);
+}