Struct Js 

#[non_exhaustive]
pub struct Js {

    pub enabled: bool,
    pub entry: Vec<String>,
    pub project: Vec<String>,
    pub ignore: Vec<String>,
    pub ignore_files: Vec<String>,
    pub ignore_dependencies: Vec<String>,
    pub ignore_binaries: Vec<String>,
    pub ignore_global_binaries: bool,
    pub ignore_unresolved: Vec<String>,
    pub ignore_workspaces: Vec<String>,
    pub ignore_exports_used_in_file: IgnoreExportsUsedInFile,
    pub ignore_members: Vec<String>,
    pub production: bool,
    pub isolate_workspaces: bool,
    pub no_gitignore: bool,
    pub include_entry_exports: bool,
    pub tsconfig: Option<String>,
    pub use_tsconfig_files: bool,
    pub include_fixtures: bool,
    pub discovery: JsDiscovery,
    pub cycles: JsCycles,
    pub workspaces: IndexMap<String, JsWorkspace>,
    pub plugins: IndexMap<String, PluginConfig>,
    pub extend_ignore: Vec<String>,
    pub extend_ignore_dependencies: Vec<String>,
    pub extend_ignore_binaries: Vec<String>,
    pub extend_ignore_unresolved: Vec<String>,
}

[js]

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

enabled: bool

Run the JavaScript analysis.

entry: Vec<String>

Entry-point globs, added to the ones plugins and package.json provide.

project: Vec<String>

Globs of the files that belong to the project.

ignore: Vec<String>

Globs of files that are not analysed.

ignore_files: Vec<String>

Globs of files, relative to the workspace root, never reported by unused-files; other rules still analyse them (knip’s ignoreFiles).

ignore_dependencies: Vec<String>

Dependencies never reported as unused or unlisted.

ignore_binaries: Vec<String>

Binaries never reported as unlisted.

ignore_global_binaries: bool

Never report the system and shell tools scripts run (rm, curl, git, docker) as unlisted binaries, since they are installed globally rather than from npm (knip’s ignoreGlobalBinaries). On by default; turn it off to have unlisted-binaries report them unless a dependency provides them.

ignore_unresolved: Vec<String>

Import specifiers never reported as unresolved. Entries are exact specifiers, globs or regular expressions (/^@org\/.+$/), see the [js] documentation.

ignore_workspaces: Vec<String>

Workspace directories (globs) the JavaScript analysis skips. Manifest and policy rules still check them.

ignore_exports_used_in_file: IgnoreExportsUsedInFile

Exports that other code in the same file uses are not reported: true for every kind, or a table of kinds.

ignore_members: Vec<String>

Enum and namespace member names (globs or regular expressions) never reported as unused.

production: bool

Analyse production code only.

isolate_workspaces: bool

knip’s strict mode. Each workspace package uses only the dependencies its own manifest lists: an import is not satisfied by a containing package or the root. Production code must import from dependencies or peerDependencies, type-only imports use no package, and required peer dependencies are checked like dependencies. Set by skif --strict; not a configuration key, so a file never sets it.

no_gitignore: bool

Find source files that .gitignore files hide (the git index is not used then). Set by skif --no-gitignore; not a configuration key.

include_entry_exports: bool

Report unused exports of entry files too.

tsconfig: Option<String>

The TypeScript configuration of the root package, relative to the workspace root and inside it, used instead of tsconfig.json for its path aliases and compiler options (knip’s --tsConfig). Other packages keep their own tsconfig.json.

use_tsconfig_files: bool

The project files of a package with a TypeScript configuration are the files its files names and those its include selects minus its exclude, instead of the project globs (knip’s --use-tsconfig-files).

include_fixtures: bool

Report files in fixtures and __fixtures__ directories as unused, and their unused exports, types and members, like any other file. Off by default: those directories hold test data that tests load by path.

discovery: JsDiscovery

How source files are found: auto lists them from the git index and re-lists from disk every directory modified since the index was written, which gives the walk’s result without walking every directory; git trusts the index alone (faster, blind to untracked and deleted files); walk always walks. Both index modes fall back to the walk when the workspace is not in a git work tree with a usable SHA-1 index.

cycles: JsCycles

What circular-imports reports.

workspaces: IndexMap<String, JsWorkspace>

Per-workspace overrides keyed by directory. The key "." is the root workspace.

plugins: IndexMap<String, PluginConfig>

Plugin switches keyed by plugin name.

extend_ignore: Vec<String>

Appended to ignore instead of replacing it. Folded away when the configuration is resolved.

extend_ignore_dependencies: Vec<String>

Appended to ignore-dependencies instead of replacing it. Folded away when the configuration is resolved.

extend_ignore_binaries: Vec<String>

Appended to ignore-binaries instead of replacing it. Folded away when the configuration is resolved.

extend_ignore_unresolved: Vec<String>

Appended to ignore-unresolved instead of replacing it. Folded away when the configuration is resolved.

Implementations

impl Js

pub fn with_entry<I, S>(self, entry: I) -> Js

where I: IntoIterator<Item = S>, S: Into<String>,

Sets the entry globs.

pub fn with_project<I, S>(self, project: I) -> Js

where I: IntoIterator<Item = S>, S: Into<String>,

Sets the project globs.

pub const fn with_enabled(self, enabled: bool) -> Js

Enables or disables the JavaScript analysis.

pub const fn with_production(self, production: bool) -> Js

Restricts the analysis to production code.

pub const fn with_isolate_workspaces(self, isolate: bool) -> Js

Makes each workspace package use only the dependencies its own manifest lists, as knip’s --strict does.

pub fn with_tsconfig(self, path: impl Into<String>) -> Js

Uses path, relative to the workspace root, as the TypeScript configuration of the root package.

pub const fn with_use_tsconfig_files(self, enabled: bool) -> Js

Takes the project files of each package with a TypeScript configuration from its files, include and exclude.

pub fn with_plugin(self, name: impl Into<String>, plugin: PluginConfig) -> Js

Switches a plugin on or off, or configures it.

Trait Implementations

impl Clone for Js

fn clone(&self) -> Js

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Js

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Js

fn default() -> Js

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Js

where Js: Default,

fn deserialize<__D>( __deserializer: __D, ) -> Result<Js, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Js

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Js

fn eq(&self, other: &Js) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Js

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Js