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


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


Pluggable TypeScript and JavaScript linter







Type Aliases




const CONFIG_EXTENSIONS: string[];


    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;


          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: FileSummary) => string;

            function createCoreModule

            createCoreModule: (globalOptions: GlobalOptions) => ContainerModule;

              function createDefaultModule

              createDefaultModule: () => ContainerModule;

                function isCodeLine

                isCodeLine: (line: string) => boolean;

                  function parseGlobalOptions

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


                    class CachedFileSystem

                    class CachedFileSystem {}


                      constructor(fs: FileSystem, cache: CacheFactory);

                        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 {}


                                            directories: DirectoryService,
                                            configProvider: ConfigurationProvider,
                                            fs: CachedFileSystem,
                                            cache: CacheFactory

                                              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: Configuration, fileName: string) => string | undefined;
                                              • Get the processor configuration for a given file.

                                              method getSettings

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

                                              method load

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

                                              method loadLocalOrResolved

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

                                              method reduce

                                              reduce: (
                                              config: Configuration,
                                              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: ContentIdHost) => string;

                                                          class DefaultBuiltinResolver

                                                          class DefaultBuiltinResolver implements BuiltinResolver {}


                                                            constructor(resolver: Resolver);

                                                              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): Cache<K, V>;
                                                                      <K = any, V = any>(weak?: false): Cache<K, V>;

                                                                        class DefaultConfigurationProvider

                                                                        class DefaultConfigurationProvider implements ConfigurationProvider {}


                                                                          fs: CachedFileSystem,
                                                                          resolver: Resolver,
                                                                          builtinResolver: BuiltinResolver,
                                                                          cache: CacheFactory

                                                                            method find

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

                                                                              method load

                                                                              load: (filename: string, context: LoadConfigurationContext) => Configuration;

                                                                                method parse

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

                                                                                  method read

                                                                                  read: (filename: string) => RawConfiguration;

                                                                                    method resolve

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

                                                                                      class DefaultDeprecationHandler

                                                                                      class DefaultDeprecationHandler implements DeprecationHandler {}


                                                                                        constructor(logger: MessageHandler);

                                                                                          method handle

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

                                                                                            class DefaultFileFilterFactory

                                                                                            class DefaultFileFilterFactory implements FileFilterFactory {}

                                                                                              method create

                                                                                              create: (context: FileFilterContext) => DefaultFileFilter;

                                                                                                class DefaultLineSwitchParser

                                                                                                class DefaultLineSwitchParser implements LineSwitchParser {}

                                                                                                  method parse

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

                                                                                                    class DefaultStatePersistence

                                                                                                    class DefaultStatePersistence implements StatePersistence {}


                                                                                                      constructor(fs: CachedFileSystem);

                                                                                                        method loadState

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

                                                                                                          method saveState

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

                                                                                                            class DependencyResolverFactory

                                                                                                            class DependencyResolverFactory {}

                                                                                                              method create

                                                                                                              create: (
                                                                                                              host: DependencyResolverHost,
                                                                                                              program: ts.Program
                                                                                                              ) => DependencyResolver;

                                                                                                                class FormatterLoader

                                                                                                                class FormatterLoader {}


                                                                                                                  constructor(host: FormatterLoaderHost, directories: DirectoryService);

                                                                                                                    method loadFormatter

                                                                                                                    loadFormatter: (name: string) => FormatterConstructor;

                                                                                                                      class LineSwitchFilterFactory

                                                                                                                      class LineSwitchFilterFactory implements FindingFilterFactory {}


                                                                                                                        constructor(parser: LineSwitchParser);

                                                                                                                          method create

                                                                                                                          create: (context: FindingFilterContext) => FindingFilter;

                                                                                                                            method getDisabledRanges

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

                                                                                                                              class Linter

                                                                                                                              class Linter {}


                                                                                                                                ruleLoader: RuleLoader,
                                                                                                                                logger: MessageHandler,
                                                                                                                                deprecationHandler: DeprecationHandler,
                                                                                                                                filterFactory: FindingFilterFactory

                                                                                                                                  method lintAndFix

                                                                                                                                  lintAndFix: (
                                                                                                                                  file: ts.SourceFile,
                                                                                                                                  content: string,
                                                                                                                                  config: EffectiveConfiguration,
                                                                                                                                  updateFile: UpdateFileCallback,
                                                                                                                                  iterations?: number,
                                                                                                                                  programFactory?: ProgramFactory,
                                                                                                                                  processor?: AbstractProcessor,
                                                                                                                                  options?: LinterOptions,
                                                                                                                                  findings?: readonly Finding[]
                                                                                                                                  ) => LintAndFixFileResult;

                                                                                                                                    method lintFile

                                                                                                                                    lintFile: (
                                                                                                                                    file: ts.SourceFile,
                                                                                                                                    config: EffectiveConfiguration,
                                                                                                                                    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(logger: MessageHandler);

                                                                                                                                                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) => Stats;

                                                                                                                                                              method writeFile

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

                                                                                                                                                                class NodeFormatterLoader

                                                                                                                                                                class NodeFormatterLoader implements FormatterLoaderHost {}


                                                                                                                                                                  constructor(resolver: Resolver, builtinResolver: BuiltinResolver);

                                                                                                                                                                    method loadCoreFormatter

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

                                                                                                                                                                      method loadCustomFormatter

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

                                                                                                                                                                        class NodeResolver

                                                                                                                                                                        class NodeResolver implements Resolver {}


                                                                                                                                                                          constructor(fs: CachedFileSystem, directories: DirectoryService);

                                                                                                                                                                            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(builtinResolver: BuiltinResolver, resolver: Resolver);

                                                                                                                                                                                      method loadCoreRule

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

                                                                                                                                                                                        method loadCustomRule

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

                                                                                                                                                                                          class ProcessorLoader

                                                                                                                                                                                          class ProcessorLoader {}


                                                                                                                                                                                            constructor(resolver: Resolver, cache: CacheFactory);

                                                                                                                                                                                              method loadProcessor

                                                                                                                                                                                              loadProcessor: (path: string) => ProcessorConstructor;

                                                                                                                                                                                                class ProgramStateFactory

                                                                                                                                                                                                class ProgramStateFactory {}


                                                                                                                                                                                                  resolverFactory: DependencyResolverFactory,
                                                                                                                                                                                                  statePersistence: StatePersistence,
                                                                                                                                                                                                  contentId: ContentId

                                                                                                                                                                                                    method create

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

                                                                                                                                                                                                      class RuleLoader

                                                                                                                                                                                                      class RuleLoader {}


                                                                                                                                                                                                        constructor(host: RuleLoaderHost, logger: MessageHandler, cache: CacheFactory);

                                                                                                                                                                                                          method loadRule

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

                                                                                                                                                                                                            class Runner

                                                                                                                                                                                                            class Runner {}


                                                                                                                                                                                                              fs: CachedFileSystem,
                                                                                                                                                                                                              configManager: ConfigurationManager,
                                                                                                                                                                                                              linter: Linter,
                                                                                                                                                                                                              processorLoader: ProcessorLoader,
                                                                                                                                                                                                              directories: DirectoryService,
                                                                                                                                                                                                              logger: MessageHandler,
                                                                                                                                                                                                              filterFactory: FileFilterFactory,
                                                                                                                                                                                                              programStateFactory: ProgramStateFactory

                                                                                                                                                                                                                method lintCollection

                                                                                                                                                                                                                lintCollection: (options: LintOptions) => LintResult;


                                                                                                                                                                                                                  interface DependencyResolver

                                                                                                                                                                                                                  interface DependencyResolver {}

                                                                                                                                                                                                                    method getDependencies

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

                                                                                                                                                                                                                      method getFilesAffectingGlobalScope

                                                                                                                                                                                                                      getFilesAffectingGlobalScope: () => readonly string[];

                                                                                                                                                                                                                        method update

                                                                                                                                                                                                                        update: (program: ts.Program, 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: () => ts.CompilerOptions;
                                                                                                                                                                                                                                                                      • Get the CompilerOptions used to create the Program.

                                                                                                                                                                                                                                                                      method getProgram

                                                                                                                                                                                                                                                                      getProgram: () => ts.Program;
                                                                                                                                                                                                                                                                      • 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: ts.Program, 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;


                                                                                                                                                                                                                                                                                                  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.


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


                                                                                                                                                                                                                                                                                                                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)


                                                                                                                                                                                                                                                                                                                                                                                              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
                                                                                                                                                                                                                                                                                                                                                                                              • 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>