@fimbul/wotan

  • Version 0.24.0
  • Published
  • 432 kB
  • 20 dependencies
  • Apache-2.0 license

Install

npm i @fimbul/wotan
yarn add @fimbul/wotan
pnpm add @fimbul/wotan

Overview

Pluggable TypeScript and JavaScript linter

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CONFIG_EXTENSIONS

const CONFIG_EXTENSIONS: string[];

    variable CONFIG_FILENAMES

    const CONFIG_FILENAMES: string[];

      variable GLOBAL_OPTIONS_SPEC

      const GLOBAL_OPTIONS_SPEC: {
      modules: OptionParser.ParseFunction<readonly string[]>;
      config: OptionParser.ParseFunction<string | undefined>;
      files: OptionParser.ParseFunction<readonly string[]>;
      exclude: OptionParser.ParseFunction<readonly string[]>;
      project: OptionParser.ParseFunction<readonly string[]>;
      references: OptionParser.ParseFunction<boolean>;
      cache: OptionParser.ParseFunction<boolean>;
      formatter: OptionParser.ParseFunction<string | undefined>;
      fix: OptionParser.ParseFunction<number | boolean>;
      extensions: OptionParser.ParseFunction<string[] | undefined>;
      reportUselessDirectives: OptionParser.ParseFunction<boolean | Severity>;
      };

        variable LINE_SWITCH_REGEX

        const LINE_SWITCH_REGEX: RegExp;

          Functions

          function applyFixes

          applyFixes: (source: string, fixes: Fix[]) => FixResult;
          • Tries to apply all fixes. The replacements of all fixes are sorted by index ascending. They are then applied in order. If a replacement overlaps (or touches) the range of the previous replacement, the process rolls back to the state before the first replacement of the offending fix was applied. The replacements of this fix are not applied again. At least one fix will be applied.

          function createBaseline

          createBaseline: (summary: any) => string;

            function createCoreModule

            createCoreModule: (globalOptions: any) => any;

              function createDefaultModule

              createDefaultModule: () => any;

                function isCodeLine

                isCodeLine: (line: string) => boolean;

                  function parseGlobalOptions

                  parseGlobalOptions: (options: GlobalOptions | undefined) => ParsedGlobalOptions;

                    Classes

                    class CachedFileSystem

                    class CachedFileSystem {}

                      constructor

                      constructor(fs: any, cache: any);

                        property realpath

                        realpath: (file: string) => string;

                          method createDirectory

                          createDirectory: (dir: string) => void;

                            method getKind

                            getKind: (file: string) => FileKind;

                              method isDirectory

                              isDirectory: (dir: string) => boolean;

                                method isFile

                                isFile: (file: string) => boolean;

                                  method readDirectory

                                  readDirectory: (dir: string) => { kind: FileKind; name: string }[];

                                    method readFile

                                    readFile: (file: string) => string;

                                      method remove

                                      remove: (file: string) => void;

                                        method writeFile

                                        writeFile: (file: string, content: string) => void;

                                          class ConfigurationManager

                                          class ConfigurationManager {}

                                            constructor

                                            constructor(
                                            directories: any,
                                            configProvider: any,
                                            fs: CachedFileSystem,
                                            cache: any
                                            );

                                              method find

                                              find: (file: string) => Configuration | undefined;
                                              • Load the configuration for the specified file.

                                              method findPath

                                              findPath: (file: string) => string | undefined;
                                              • Look up the location of the configuration file for the specified file name.

                                              method getProcessor

                                              getProcessor: (config: any, fileName: string) => string | undefined;
                                              • Get the processor configuration for a given file.

                                              method getSettings

                                              getSettings: (config: any, fileName: string) => any;
                                              • Get the settings for a given file.

                                              method load

                                              load: (fileName: string) => any;
                                              • Load a configuration from a resolved path using the ConfigurationProvider, recursively resolving and loading base configs.

                                              method loadLocalOrResolved

                                              loadLocalOrResolved: (pathOrName: string, basedir?: string) => any;
                                              • Load the given config from a local file if it exists or from the resolved path otherwise

                                              method reduce

                                              reduce: (config: any, file: string) => ReducedConfiguration | undefined;
                                              • Collects all matching configuration options for the given file. Flattens all base configs and matches overrides. Returns undefined if the file is excluded in one of the configuraton files.

                                              method resolve

                                              resolve: (name: string, basedir: string) => string;
                                              • Resolve a configuration name to it's absolute path.

                                                Parameter name

                                                name of a builtin config - package name in node_modules or a submodule thereof - absolute path - relative path starting with ./ or ../

                                              class ConsoleMessageHandler

                                              class ConsoleMessageHandler implements MessageHandler {}

                                                method error

                                                error: (e: Error) => void;

                                                  method log

                                                  log: (message: string) => void;

                                                    method warn

                                                    warn: (message: string) => void;

                                                      class ContentHasher

                                                      class ContentHasher implements ContentId {}

                                                        method forFile

                                                        forFile: (fileName: string, host: any) => string;

                                                          class DefaultBuiltinResolver

                                                          class DefaultBuiltinResolver implements BuiltinResolver {}

                                                            constructor

                                                            constructor(resolver: any);

                                                              method resolveConfig

                                                              resolveConfig: (name: string) => string;

                                                                method resolveFormatter

                                                                resolveFormatter: (name: string) => string;

                                                                  method resolveRule

                                                                  resolveRule: (name: string) => string;

                                                                    class DefaultCacheFactory

                                                                    class DefaultCacheFactory implements CacheFactory {}

                                                                      method create

                                                                      create: {
                                                                      <K extends object, V = any>(weak: true): any;
                                                                      <K = any, V = any>(weak?: false): any;
                                                                      };

                                                                        class DefaultConfigurationProvider

                                                                        class DefaultConfigurationProvider implements ConfigurationProvider {}

                                                                          constructor

                                                                          constructor(
                                                                          fs: CachedFileSystem,
                                                                          resolver: any,
                                                                          builtinResolver: any,
                                                                          cache: any
                                                                          );

                                                                            method find

                                                                            find: (fileToLint: string) => string | undefined;

                                                                              method load

                                                                              load: (filename: string, context: any) => any;

                                                                                method parse

                                                                                parse: (raw: RawConfiguration, filename: string, context: any) => any;

                                                                                  method read

                                                                                  read: (filename: string) => RawConfiguration;

                                                                                    method resolve

                                                                                    resolve: (name: string, basedir: string) => string;

                                                                                      class DefaultDeprecationHandler

                                                                                      class DefaultDeprecationHandler implements DeprecationHandler {}

                                                                                        constructor

                                                                                        constructor(logger: any);

                                                                                          method handle

                                                                                          handle: (target: any, name: string, text?: string) => void;

                                                                                            class DefaultFileFilterFactory

                                                                                            class DefaultFileFilterFactory implements FileFilterFactory {}

                                                                                              method create

                                                                                              create: (context: any) => DefaultFileFilter;

                                                                                                class DefaultLineSwitchParser

                                                                                                class DefaultLineSwitchParser implements LineSwitchParser {}

                                                                                                  method parse

                                                                                                  parse: (context: any) => RawLineSwitch[];

                                                                                                    class DefaultStatePersistence

                                                                                                    class DefaultStatePersistence implements StatePersistence {}

                                                                                                      constructor

                                                                                                      constructor(fs: CachedFileSystem);

                                                                                                        method loadState

                                                                                                        loadState: (project: string) => StaticProgramState | undefined;

                                                                                                          method saveState

                                                                                                          saveState: (project: string, state: any) => void;

                                                                                                            class DependencyResolverFactory

                                                                                                            class DependencyResolverFactory {}

                                                                                                              method create

                                                                                                              create: (host: DependencyResolverHost, program: any) => DependencyResolver;

                                                                                                                class FormatterLoader

                                                                                                                class FormatterLoader {}

                                                                                                                  constructor

                                                                                                                  constructor(host: any, directories: any);

                                                                                                                    method loadFormatter

                                                                                                                    loadFormatter: (name: string) => any;

                                                                                                                      class LineSwitchFilterFactory

                                                                                                                      class LineSwitchFilterFactory implements FindingFilterFactory {}

                                                                                                                        constructor

                                                                                                                        constructor(parser: any);

                                                                                                                          method create

                                                                                                                          create: (context: any) => any;

                                                                                                                            method getDisabledRanges

                                                                                                                            getDisabledRanges: (context: any) => Map<string, ts.TextRange[]>;

                                                                                                                              class Linter

                                                                                                                              class Linter {}

                                                                                                                                constructor

                                                                                                                                constructor(
                                                                                                                                ruleLoader: RuleLoader,
                                                                                                                                logger: any,
                                                                                                                                deprecationHandler: any,
                                                                                                                                filterFactory: any
                                                                                                                                );

                                                                                                                                  method lintAndFix

                                                                                                                                  lintAndFix: (
                                                                                                                                  file: any,
                                                                                                                                  content: string,
                                                                                                                                  config: any,
                                                                                                                                  updateFile: UpdateFileCallback,
                                                                                                                                  iterations?: number,
                                                                                                                                  programFactory?: ProgramFactory,
                                                                                                                                  processor?: any,
                                                                                                                                  options?: LinterOptions,
                                                                                                                                  findings?: readonly Finding[]
                                                                                                                                  ) => any;

                                                                                                                                    method lintFile

                                                                                                                                    lintFile: (
                                                                                                                                    file: any,
                                                                                                                                    config: any,
                                                                                                                                    programOrFactory?: ProgramFactory | ts.Program,
                                                                                                                                    options?: LinterOptions
                                                                                                                                    ) => ReadonlyArray<Finding>;

                                                                                                                                      class NodeDirectoryService

                                                                                                                                      class NodeDirectoryService implements DirectoryService {}

                                                                                                                                        method getCurrentDirectory

                                                                                                                                        getCurrentDirectory: () => string;

                                                                                                                                          method getHomeDirectory

                                                                                                                                          getHomeDirectory: () => string;

                                                                                                                                            class NodeFileSystem

                                                                                                                                            class NodeFileSystem implements FileSystem {}

                                                                                                                                              constructor

                                                                                                                                              constructor(logger: any);

                                                                                                                                                method createDirectory

                                                                                                                                                createDirectory: (dir: string) => void;

                                                                                                                                                  method deleteFile

                                                                                                                                                  deleteFile: (path: string) => void;

                                                                                                                                                    method normalizePath

                                                                                                                                                    static normalizePath: (path: string) => string;

                                                                                                                                                      method readDirectory

                                                                                                                                                      readDirectory: (dir: string) => Array<string | Dirent>;

                                                                                                                                                        method readFile

                                                                                                                                                        readFile: (file: string) => string;

                                                                                                                                                          method realpath

                                                                                                                                                          realpath: (path: string) => string;

                                                                                                                                                            method stat

                                                                                                                                                            stat: (path: string) => any;

                                                                                                                                                              method writeFile

                                                                                                                                                              writeFile: (file: string, content: string) => void;

                                                                                                                                                                class NodeFormatterLoader

                                                                                                                                                                class NodeFormatterLoader implements FormatterLoaderHost {}

                                                                                                                                                                  constructor

                                                                                                                                                                  constructor(resolver: any, builtinResolver: any);

                                                                                                                                                                    method loadCoreFormatter

                                                                                                                                                                    loadCoreFormatter: (name: string) => FormatterConstructor | undefined;

                                                                                                                                                                      method loadCustomFormatter

                                                                                                                                                                      loadCustomFormatter: (
                                                                                                                                                                      name: string,
                                                                                                                                                                      basedir: string
                                                                                                                                                                      ) => FormatterConstructor | undefined;

                                                                                                                                                                        class NodeResolver

                                                                                                                                                                        class NodeResolver implements Resolver {}

                                                                                                                                                                          constructor

                                                                                                                                                                          constructor(fs: CachedFileSystem, directories: any);

                                                                                                                                                                            method getDefaultExtensions

                                                                                                                                                                            getDefaultExtensions: () => readonly string[];

                                                                                                                                                                              method require

                                                                                                                                                                              require: (id: string, options?: { cache?: boolean }) => any;

                                                                                                                                                                                method resolve

                                                                                                                                                                                resolve: (
                                                                                                                                                                                id: string,
                                                                                                                                                                                basedir?: string,
                                                                                                                                                                                extensions?: readonly string[],
                                                                                                                                                                                paths?: ReadonlyArray<string>
                                                                                                                                                                                ) => string;

                                                                                                                                                                                  class NodeRuleLoader

                                                                                                                                                                                  class NodeRuleLoader implements RuleLoaderHost {}

                                                                                                                                                                                    constructor

                                                                                                                                                                                    constructor(builtinResolver: any, resolver: any);

                                                                                                                                                                                      method loadCoreRule

                                                                                                                                                                                      loadCoreRule: (name: string) => RuleConstructor | undefined;

                                                                                                                                                                                        method loadCustomRule

                                                                                                                                                                                        loadCustomRule: (name: string, directory: string) => RuleConstructor | undefined;

                                                                                                                                                                                          class ProcessorLoader

                                                                                                                                                                                          class ProcessorLoader {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(resolver: any, cache: any);

                                                                                                                                                                                              method loadProcessor

                                                                                                                                                                                              loadProcessor: (path: string) => any;

                                                                                                                                                                                                class ProgramStateFactory

                                                                                                                                                                                                class ProgramStateFactory {}

                                                                                                                                                                                                  constructor

                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                  resolverFactory: DependencyResolverFactory,
                                                                                                                                                                                                  statePersistence: any,
                                                                                                                                                                                                  contentId: any
                                                                                                                                                                                                  );

                                                                                                                                                                                                    method create

                                                                                                                                                                                                    create: (
                                                                                                                                                                                                    program: any,
                                                                                                                                                                                                    host: ProgramStateHost & DependencyResolverHost,
                                                                                                                                                                                                    tsconfigPath: string
                                                                                                                                                                                                    ) => ProgramStateImpl;

                                                                                                                                                                                                      class RuleLoader

                                                                                                                                                                                                      class RuleLoader {}

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(host: any, logger: any, cache: any);

                                                                                                                                                                                                          method loadRule

                                                                                                                                                                                                          loadRule: (
                                                                                                                                                                                                          name: string,
                                                                                                                                                                                                          directories: ReadonlyArray<string> | undefined
                                                                                                                                                                                                          ) => RuleConstructor | undefined;

                                                                                                                                                                                                            class Runner

                                                                                                                                                                                                            class Runner {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                              fs: CachedFileSystem,
                                                                                                                                                                                                              configManager: ConfigurationManager,
                                                                                                                                                                                                              linter: Linter,
                                                                                                                                                                                                              processorLoader: ProcessorLoader,
                                                                                                                                                                                                              directories: any,
                                                                                                                                                                                                              logger: any,
                                                                                                                                                                                                              filterFactory: any,
                                                                                                                                                                                                              programStateFactory: ProgramStateFactory
                                                                                                                                                                                                              );

                                                                                                                                                                                                                method lintCollection

                                                                                                                                                                                                                lintCollection: (options: LintOptions) => any;

                                                                                                                                                                                                                  Interfaces

                                                                                                                                                                                                                  interface DependencyResolver

                                                                                                                                                                                                                  interface DependencyResolver {}

                                                                                                                                                                                                                    method getDependencies

                                                                                                                                                                                                                    getDependencies: (
                                                                                                                                                                                                                    fileName: string
                                                                                                                                                                                                                    ) => ReadonlyMap<string, null | readonly string[]>;

                                                                                                                                                                                                                      method getFilesAffectingGlobalScope

                                                                                                                                                                                                                      getFilesAffectingGlobalScope: () => readonly string[];

                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                        update: (program: any, updatedFile: string) => void;

                                                                                                                                                                                                                          interface DirectoryEntryWithKind

                                                                                                                                                                                                                          interface DirectoryEntryWithKind {}

                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                            kind: FileKind;

                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                interface FixResult

                                                                                                                                                                                                                                interface FixResult {}

                                                                                                                                                                                                                                  property fixed

                                                                                                                                                                                                                                  fixed: number;

                                                                                                                                                                                                                                    property range

                                                                                                                                                                                                                                    range: ts.TextChangeRange;

                                                                                                                                                                                                                                      property result

                                                                                                                                                                                                                                      result: string;

                                                                                                                                                                                                                                        interface LinterOptions

                                                                                                                                                                                                                                        interface LinterOptions {}

                                                                                                                                                                                                                                          property reportUselessDirectives

                                                                                                                                                                                                                                          reportUselessDirectives?: Severity;

                                                                                                                                                                                                                                            interface LintOptions

                                                                                                                                                                                                                                            interface LintOptions {}

                                                                                                                                                                                                                                              property cache

                                                                                                                                                                                                                                              cache: boolean;

                                                                                                                                                                                                                                                property config

                                                                                                                                                                                                                                                config: string | undefined;

                                                                                                                                                                                                                                                  property exclude

                                                                                                                                                                                                                                                  exclude: ReadonlyArray<string>;

                                                                                                                                                                                                                                                    property extensions

                                                                                                                                                                                                                                                    extensions: ReadonlyArray<string> | undefined;

                                                                                                                                                                                                                                                      property files

                                                                                                                                                                                                                                                      files: ReadonlyArray<string>;

                                                                                                                                                                                                                                                        property fix

                                                                                                                                                                                                                                                        fix: boolean | number;

                                                                                                                                                                                                                                                          property project

                                                                                                                                                                                                                                                          project: ReadonlyArray<string>;

                                                                                                                                                                                                                                                            property references

                                                                                                                                                                                                                                                            references: boolean;

                                                                                                                                                                                                                                                              property reportUselessDirectives

                                                                                                                                                                                                                                                              reportUselessDirectives: Severity | boolean | undefined;

                                                                                                                                                                                                                                                                interface ParsedGlobalOptions

                                                                                                                                                                                                                                                                interface ParsedGlobalOptions extends LintOptions {}

                                                                                                                                                                                                                                                                  property formatter

                                                                                                                                                                                                                                                                  formatter: string | undefined;

                                                                                                                                                                                                                                                                    property modules

                                                                                                                                                                                                                                                                    modules: ReadonlyArray<string>;

                                                                                                                                                                                                                                                                      interface ProgramFactory

                                                                                                                                                                                                                                                                      interface ProgramFactory {}
                                                                                                                                                                                                                                                                      • This factory is used to lazily create or update the Program only when necessary.

                                                                                                                                                                                                                                                                      method getCompilerOptions

                                                                                                                                                                                                                                                                      getCompilerOptions: () => any;
                                                                                                                                                                                                                                                                      • Get the CompilerOptions used to create the Program.

                                                                                                                                                                                                                                                                      method getProgram

                                                                                                                                                                                                                                                                      getProgram: () => any;
                                                                                                                                                                                                                                                                      • This method is called to retrieve the Program on the first use. It should create or update the Program if necessary.

                                                                                                                                                                                                                                                                      interface ProgramState

                                                                                                                                                                                                                                                                      interface ProgramState {}

                                                                                                                                                                                                                                                                        method getUpToDateResult

                                                                                                                                                                                                                                                                        getUpToDateResult: (
                                                                                                                                                                                                                                                                        fileName: string,
                                                                                                                                                                                                                                                                        configHash: string
                                                                                                                                                                                                                                                                        ) => readonly Finding[] | undefined;

                                                                                                                                                                                                                                                                          method save

                                                                                                                                                                                                                                                                          save: () => void;

                                                                                                                                                                                                                                                                            method setFileResult

                                                                                                                                                                                                                                                                            setFileResult: (
                                                                                                                                                                                                                                                                            fileName: string,
                                                                                                                                                                                                                                                                            configHash: string,
                                                                                                                                                                                                                                                                            result: readonly Finding[]
                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                              method update

                                                                                                                                                                                                                                                                              update: (program: any, updatedFile: string) => void;

                                                                                                                                                                                                                                                                                interface RawConfiguration

                                                                                                                                                                                                                                                                                interface RawConfiguration {}

                                                                                                                                                                                                                                                                                  property aliases

                                                                                                                                                                                                                                                                                  aliases?: RawConfiguration.AliasMap;

                                                                                                                                                                                                                                                                                    property exclude

                                                                                                                                                                                                                                                                                    exclude?: string | ReadonlyArray<string>;

                                                                                                                                                                                                                                                                                      property extends

                                                                                                                                                                                                                                                                                      extends?: string | ReadonlyArray<string>;

                                                                                                                                                                                                                                                                                        property overrides

                                                                                                                                                                                                                                                                                        overrides?: ReadonlyArray<RawConfiguration.Override>;

                                                                                                                                                                                                                                                                                          property processor

                                                                                                                                                                                                                                                                                          processor?: string | null | false;

                                                                                                                                                                                                                                                                                            property rules

                                                                                                                                                                                                                                                                                            rules?: RawConfiguration.RuleMap;

                                                                                                                                                                                                                                                                                              property rulesDirectories

                                                                                                                                                                                                                                                                                              rulesDirectories?: RawConfiguration.RulesDirectoryMap;

                                                                                                                                                                                                                                                                                                property settings

                                                                                                                                                                                                                                                                                                settings?: RawConfiguration.SettingsMap;

                                                                                                                                                                                                                                                                                                  Enums

                                                                                                                                                                                                                                                                                                  enum FileKind

                                                                                                                                                                                                                                                                                                  enum FileKind {
                                                                                                                                                                                                                                                                                                  NonExistent = 0,
                                                                                                                                                                                                                                                                                                  File = 1,
                                                                                                                                                                                                                                                                                                  Directory = 2,
                                                                                                                                                                                                                                                                                                  Other = 3,
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    member Directory

                                                                                                                                                                                                                                                                                                    Directory = 2

                                                                                                                                                                                                                                                                                                      member File

                                                                                                                                                                                                                                                                                                      File = 1

                                                                                                                                                                                                                                                                                                        member NonExistent

                                                                                                                                                                                                                                                                                                        NonExistent = 0

                                                                                                                                                                                                                                                                                                          member Other

                                                                                                                                                                                                                                                                                                          Other = 3

                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                            type DependencyResolverHost

                                                                                                                                                                                                                                                                                                            type DependencyResolverHost = Required<
                                                                                                                                                                                                                                                                                                            Pick<ts.CompilerHost, 'resolveModuleNames'>
                                                                                                                                                                                                                                                                                                            > & {
                                                                                                                                                                                                                                                                                                            useSourceOfProjectReferenceRedirect?(): boolean;
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              type ProgramStateHost

                                                                                                                                                                                                                                                                                                              type ProgramStateHost = Pick<ts.CompilerHost, 'useCaseSensitiveFileNames'>;

                                                                                                                                                                                                                                                                                                                type UpdateFileCallback

                                                                                                                                                                                                                                                                                                                type UpdateFileCallback = (
                                                                                                                                                                                                                                                                                                                content: string,
                                                                                                                                                                                                                                                                                                                range: ts.TextChangeRange
                                                                                                                                                                                                                                                                                                                ) => ts.SourceFile | undefined;
                                                                                                                                                                                                                                                                                                                • Creates a new SourceFile from the updated source.

                                                                                                                                                                                                                                                                                                                  Returns

                                                                                                                                                                                                                                                                                                                  the new SourceFile on success or undefined to roll back the latest set of changes.

                                                                                                                                                                                                                                                                                                                Namespaces

                                                                                                                                                                                                                                                                                                                namespace OptionParser

                                                                                                                                                                                                                                                                                                                namespace OptionParser {}

                                                                                                                                                                                                                                                                                                                  function parse

                                                                                                                                                                                                                                                                                                                  parse: <T extends Record<string, ParseFunction<any>>>(
                                                                                                                                                                                                                                                                                                                  options: Record<string, any> | undefined,
                                                                                                                                                                                                                                                                                                                  specs: T,
                                                                                                                                                                                                                                                                                                                  config: ParseConfig
                                                                                                                                                                                                                                                                                                                  ) => ParsedOptions<T>;

                                                                                                                                                                                                                                                                                                                    interface ParseConfig

                                                                                                                                                                                                                                                                                                                    interface ParseConfig {}

                                                                                                                                                                                                                                                                                                                      property context

                                                                                                                                                                                                                                                                                                                      context: string;

                                                                                                                                                                                                                                                                                                                        property exhaustive

                                                                                                                                                                                                                                                                                                                        exhaustive?: boolean;

                                                                                                                                                                                                                                                                                                                          property validate

                                                                                                                                                                                                                                                                                                                          validate?: boolean;

                                                                                                                                                                                                                                                                                                                            type MismatchCallback

                                                                                                                                                                                                                                                                                                                            type MismatchCallback = (type: string) => void;

                                                                                                                                                                                                                                                                                                                              type ParsedOptions

                                                                                                                                                                                                                                                                                                                              type ParsedOptions<T extends Record<string, ParseFunction<any>>> = {
                                                                                                                                                                                                                                                                                                                              [K in keyof T]: ReturnType<T[K]>;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                type ParseFunction

                                                                                                                                                                                                                                                                                                                                type ParseFunction<T> = (value: any, report: MismatchCallback) => T;

                                                                                                                                                                                                                                                                                                                                  namespace OptionParser.Factory

                                                                                                                                                                                                                                                                                                                                  namespace OptionParser.Factory {}

                                                                                                                                                                                                                                                                                                                                    function parsePrimitive

                                                                                                                                                                                                                                                                                                                                    parsePrimitive: <T extends PrimitiveName[]>(
                                                                                                                                                                                                                                                                                                                                    ...types: T
                                                                                                                                                                                                                                                                                                                                    ) => ParseFunction<PrimitiveMap<T[number]> | undefined>;

                                                                                                                                                                                                                                                                                                                                      function parsePrimitiveOrArray

                                                                                                                                                                                                                                                                                                                                      parsePrimitiveOrArray: <T extends PrimitiveName>(
                                                                                                                                                                                                                                                                                                                                      type: T
                                                                                                                                                                                                                                                                                                                                      ) => ParseFunction<ReadonlyArray<PrimitiveMap<T>> | undefined>;

                                                                                                                                                                                                                                                                                                                                        namespace OptionParser.Transform

                                                                                                                                                                                                                                                                                                                                        namespace OptionParser.Transform {}

                                                                                                                                                                                                                                                                                                                                          function map

                                                                                                                                                                                                                                                                                                                                          map: <T extends readonly U[], U, V>(
                                                                                                                                                                                                                                                                                                                                          parseFn: ParseFunction<T>,
                                                                                                                                                                                                                                                                                                                                          cb: (item: U) => V
                                                                                                                                                                                                                                                                                                                                          ) => ParseFunction<{ -readonly [K in keyof T]: V }>;

                                                                                                                                                                                                                                                                                                                                            function noDefault

                                                                                                                                                                                                                                                                                                                                            noDefault: <T>(parseFn: ParseFunction<T>) => ParseFunction<T | undefined>;

                                                                                                                                                                                                                                                                                                                                              function transform

                                                                                                                                                                                                                                                                                                                                              transform: <T, U>(
                                                                                                                                                                                                                                                                                                                                              parseFn: ParseFunction<T>,
                                                                                                                                                                                                                                                                                                                                              cb: (value: T) => U
                                                                                                                                                                                                                                                                                                                                              ) => ParseFunction<U>;

                                                                                                                                                                                                                                                                                                                                                function withDefault

                                                                                                                                                                                                                                                                                                                                                withDefault: <T>(
                                                                                                                                                                                                                                                                                                                                                parseFn: ParseFunction<T | undefined>,
                                                                                                                                                                                                                                                                                                                                                defaultValue: T
                                                                                                                                                                                                                                                                                                                                                ) => ParseFunction<T>;

                                                                                                                                                                                                                                                                                                                                                  namespace RawConfiguration

                                                                                                                                                                                                                                                                                                                                                  namespace RawConfiguration {}

                                                                                                                                                                                                                                                                                                                                                    interface Alias

                                                                                                                                                                                                                                                                                                                                                    interface Alias {}

                                                                                                                                                                                                                                                                                                                                                      property options

                                                                                                                                                                                                                                                                                                                                                      options?: any;

                                                                                                                                                                                                                                                                                                                                                        property rule

                                                                                                                                                                                                                                                                                                                                                        rule: string;

                                                                                                                                                                                                                                                                                                                                                          interface AliasMap

                                                                                                                                                                                                                                                                                                                                                          interface AliasMap {}

                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                            [prefix: string]:
                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                            [name: string]: RawConfiguration.Alias | null | false | string;
                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                            | null
                                                                                                                                                                                                                                                                                                                                                            | false;

                                                                                                                                                                                                                                                                                                                                                              interface Override

                                                                                                                                                                                                                                                                                                                                                              interface Override {}

                                                                                                                                                                                                                                                                                                                                                                property files

                                                                                                                                                                                                                                                                                                                                                                files: string | ReadonlyArray<string>;

                                                                                                                                                                                                                                                                                                                                                                  property processor

                                                                                                                                                                                                                                                                                                                                                                  processor?: string | null | false;

                                                                                                                                                                                                                                                                                                                                                                    property rules

                                                                                                                                                                                                                                                                                                                                                                    rules?: RuleMap;

                                                                                                                                                                                                                                                                                                                                                                      property settings

                                                                                                                                                                                                                                                                                                                                                                      settings?: SettingsMap;

                                                                                                                                                                                                                                                                                                                                                                        interface RuleConfig

                                                                                                                                                                                                                                                                                                                                                                        interface RuleConfig {}

                                                                                                                                                                                                                                                                                                                                                                          property options

                                                                                                                                                                                                                                                                                                                                                                          options?: any;

                                                                                                                                                                                                                                                                                                                                                                            property severity

                                                                                                                                                                                                                                                                                                                                                                            severity?: RuleSeverity;

                                                                                                                                                                                                                                                                                                                                                                              interface RuleMap

                                                                                                                                                                                                                                                                                                                                                                              interface RuleMap {}

                                                                                                                                                                                                                                                                                                                                                                                index signature

                                                                                                                                                                                                                                                                                                                                                                                [key: string]: RawConfiguration.RuleConfigValue;

                                                                                                                                                                                                                                                                                                                                                                                  interface RulesDirectoryMap

                                                                                                                                                                                                                                                                                                                                                                                  interface RulesDirectoryMap {}

                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                    [prefix: string]: string;

                                                                                                                                                                                                                                                                                                                                                                                      interface SettingsMap

                                                                                                                                                                                                                                                                                                                                                                                      interface SettingsMap {}

                                                                                                                                                                                                                                                                                                                                                                                        index signature

                                                                                                                                                                                                                                                                                                                                                                                        [key: string]: any;

                                                                                                                                                                                                                                                                                                                                                                                          type RuleConfigValue

                                                                                                                                                                                                                                                                                                                                                                                          type RuleConfigValue = RuleSeverity | RuleConfig | null;

                                                                                                                                                                                                                                                                                                                                                                                            type RuleSeverity

                                                                                                                                                                                                                                                                                                                                                                                            type RuleSeverity = 'off' | 'warn' | 'warning' | 'error' | 'suggestion' | 'hint';

                                                                                                                                                                                                                                                                                                                                                                                              Package Files (30)

                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (20)

                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (10)

                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (1)

                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@fimbul/wotan.

                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@fimbul/wotan)
                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@fimbul/wotan"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>