Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@biomejs/wasm-nodejs

Package Overview
Dependencies
Maintainers
4
Versions
73
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@biomejs/wasm-nodejs - npm Package Compare versions

Comparing version 1.5.3 to 1.6.0

910

biome_wasm.d.ts

@@ -8,6 +8,6 @@ /* tslint:disable */

feature: FeatureName[];
path: RomePath;
path: BiomePath;
}
type FeatureName = "Format" | "Lint" | "OrganizeImports";
interface RomePath {
interface BiomePath {
path: string;

@@ -25,3 +25,3 @@ }

interface UpdateSettingsParams {
configuration: Configuration;
configuration: PartialConfiguration;
gitignore_matches: string[];

@@ -31,3 +31,3 @@ vcs_base_path?: string;

}
interface Configuration {
interface PartialConfiguration {
/**

@@ -40,3 +40,3 @@ * A field for the [JSON schema](https://json-schema.org/) specification

*/
css?: CssConfiguration;
css?: PartialCssConfiguration;
/**

@@ -49,23 +49,23 @@ * A list of paths to other JSON files, used to extends the current configuration.

*/
files?: FilesConfiguration;
files?: PartialFilesConfiguration;
/**
* The configuration of the formatter
*/
formatter?: FormatterConfiguration;
formatter?: PartialFormatterConfiguration;
/**
* Specific configuration for the JavaScript language
*/
javascript?: JavascriptConfiguration;
javascript?: PartialJavascriptConfiguration;
/**
* Specific configuration for the Json language
*/
json?: JsonConfiguration;
json?: PartialJsonConfiguration;
/**
* The configuration for the linter
*/
linter?: LinterConfiguration;
linter?: PartialLinterConfiguration;
/**
* The configuration of the import sorting
*/
organizeImports?: OrganizeImports;
organizeImports?: PartialOrganizeImports;
/**

@@ -78,16 +78,16 @@ * A list of granular patterns that should be applied only to a sub set of files

*/
vcs?: VcsConfiguration;
vcs?: PartialVcsConfiguration;
}
interface CssConfiguration {
interface PartialCssConfiguration {
/**
* Formatting options
*/
formatter?: CssFormatter;
formatter?: PartialCssFormatter;
/**
* Parsing options
*/
parser?: CssParser;
parser?: PartialCssParser;
}
type StringSet = string[];
interface FilesConfiguration {
interface PartialFilesConfiguration {
/**

@@ -110,3 +110,7 @@ * A list of Unix shell style patterns. Biome will ignore files/folders that will match these patterns.

}
interface FormatterConfiguration {
interface PartialFormatterConfiguration {
/**
* The attribute position style. By default auto.
*/
attributePosition?: AttributePosition;
enabled?: boolean;

@@ -146,7 +150,7 @@ /**

}
interface JavascriptConfiguration {
interface PartialJavascriptConfiguration {
/**
* Formatting options
*/
formatter?: JavascriptFormatter;
formatter?: PartialJavascriptFormatter;
/**

@@ -158,19 +162,19 @@ * A list of global bindings that should be ignored by the analyzers

globals?: StringSet;
organize_imports?: JavascriptOrganizeImports;
organize_imports?: PartialJavascriptOrganizeImports;
/**
* Parsing options
*/
parser?: JavascriptParser;
parser?: PartialJavascriptParser;
}
interface JsonConfiguration {
interface PartialJsonConfiguration {
/**
* Formatting options
*/
formatter?: JsonFormatter;
formatter?: PartialJsonFormatter;
/**
* Parsing options
*/
parser?: JsonParser;
parser?: PartialJsonParser;
}
interface LinterConfiguration {
interface PartialLinterConfiguration {
/**

@@ -193,3 +197,3 @@ * if `false`, it disables the feature and the linter won't be executed. `true` by default

}
interface OrganizeImports {
interface PartialOrganizeImports {
/**

@@ -209,3 +213,3 @@ * Enables the organization of imports

type Overrides = OverridePattern[];
interface VcsConfiguration {
interface PartialVcsConfiguration {
/**

@@ -234,3 +238,3 @@ * The kind of client.

}
interface CssFormatter {
interface PartialCssFormatter {
/**

@@ -262,3 +266,3 @@ * Control the formatter for CSS (and its super languages) files.

}
interface CssParser {
interface PartialCssParser {
/**

@@ -269,6 +273,7 @@ * Allow comments to appear on incorrect lines in `.css` files

}
type AttributePosition = "auto" | "multiline";
type PlainIndentStyle = "tab" | "space";
type LineEnding = "lf" | "crlf" | "cr";
type LineWidth = number;
interface JavascriptFormatter {
interface PartialJavascriptFormatter {
/**

@@ -279,2 +284,6 @@ * Whether to add non-necessary parentheses to arrow functions. Defaults to "always".

/**
* The attribute position style in JavaScript code. Defaults to auto.
*/
attributePosition?: AttributePosition;
/**
* Whether to hug the closing bracket of multiline HTML/JSX tags to the end of the last line, rather than being alone on the following line. Defaults to false.

@@ -332,4 +341,4 @@ */

}
interface JavascriptOrganizeImports {}
interface JavascriptParser {
interface PartialJavascriptOrganizeImports {}
interface PartialJavascriptParser {
/**

@@ -342,3 +351,3 @@ * It enables the experimental and unsafe parsing of parameter decorators

}
interface JsonFormatter {
interface PartialJsonFormatter {
/**

@@ -368,4 +377,8 @@ * Control the formatter for JSON (and its super languages) files.

lineWidth?: LineWidth;
/**
* Print trailing commas wherever possible in multi-line comma-separated syntactic structures. Defaults to "none".
*/
trailingCommas?: TrailingCommas;
}
interface JsonParser {
interface PartialJsonParser {
/**

@@ -402,3 +415,3 @@ * Allow parsing comments in `.json` files

*/
css?: CssConfiguration;
css?: PartialCssConfiguration;
/**

@@ -419,7 +432,7 @@ * Specific configuration for the Json language

*/
javascript?: JavascriptConfiguration;
javascript?: PartialJavascriptConfiguration;
/**
* Specific configuration for the Json language
*/
json?: JsonConfiguration;
json?: PartialJsonConfiguration;
/**

@@ -440,2 +453,3 @@ * Specific configuration for the Json language

type TrailingComma = "all" | "es5" | "none";
type TrailingCommas = "none" | "all";
interface A11y {

@@ -449,55 +463,55 @@ /**

*/
noAccessKey?: RuleConfiguration;
noAccessKey?: RuleConfiguration_for_Null;
/**
* Enforce that aria-hidden="true" is not set on focusable elements.
*/
noAriaHiddenOnFocusable?: RuleConfiguration;
noAriaHiddenOnFocusable?: RuleConfiguration_for_Null;
/**
* Enforce that elements that do not support ARIA roles, states, and properties do not have those attributes.
*/
noAriaUnsupportedElements?: RuleConfiguration;
noAriaUnsupportedElements?: RuleConfiguration_for_Null;
/**
* Enforce that autoFocus prop is not used on elements.
*/
noAutofocus?: RuleConfiguration;
noAutofocus?: RuleConfiguration_for_Null;
/**
* Disallow target="_blank" attribute without rel="noreferrer"
*/
noBlankTarget?: RuleConfiguration;
noBlankTarget?: RuleConfiguration_for_Null;
/**
* Enforces that no distracting elements are used.
*/
noDistractingElements?: RuleConfiguration;
noDistractingElements?: RuleConfiguration_for_Null;
/**
* The scope prop should be used only on <th> elements.
*/
noHeaderScope?: RuleConfiguration;
noHeaderScope?: RuleConfiguration_for_Null;
/**
* Enforce that non-interactive ARIA roles are not assigned to interactive HTML elements.
*/
noInteractiveElementToNoninteractiveRole?: RuleConfiguration;
noInteractiveElementToNoninteractiveRole?: RuleConfiguration_for_Null;
/**
* Enforce that interactive ARIA roles are not assigned to non-interactive HTML elements.
*/
noNoninteractiveElementToInteractiveRole?: RuleConfiguration;
noNoninteractiveElementToInteractiveRole?: RuleConfiguration_for_Null;
/**
* Enforce that tabIndex is not assigned to non-interactive HTML elements.
*/
noNoninteractiveTabindex?: RuleConfiguration;
noNoninteractiveTabindex?: RuleConfiguration_for_Null;
/**
* Prevent the usage of positive integers on tabIndex property
*/
noPositiveTabindex?: RuleConfiguration;
noPositiveTabindex?: RuleConfiguration_for_Null;
/**
* Enforce img alt prop does not contain the word "image", "picture", or "photo".
*/
noRedundantAlt?: RuleConfiguration;
noRedundantAlt?: RuleConfiguration_for_Null;
/**
* Enforce explicit role property is not the same as implicit/default role property on an element.
*/
noRedundantRoles?: RuleConfiguration;
noRedundantRoles?: RuleConfiguration_for_Null;
/**
* Enforces the usage of the title element for the svg element.
*/
noSvgWithoutTitle?: RuleConfiguration;
noSvgWithoutTitle?: RuleConfiguration_for_Null;
/**

@@ -510,63 +524,63 @@ * It enables the recommended rules for this group

*/
useAltText?: RuleConfiguration;
useAltText?: RuleConfiguration_for_Null;
/**
* Enforce that anchors have content and that the content is accessible to screen readers.
*/
useAnchorContent?: RuleConfiguration;
useAnchorContent?: RuleConfiguration_for_Null;
/**
* Enforce that tabIndex is assigned to non-interactive HTML elements with aria-activedescendant.
*/
useAriaActivedescendantWithTabindex?: RuleConfiguration;
useAriaActivedescendantWithTabindex?: RuleConfiguration_for_Null;
/**
* Enforce that elements with ARIA roles must have all required ARIA attributes for that role.
*/
useAriaPropsForRole?: RuleConfiguration;
useAriaPropsForRole?: RuleConfiguration_for_Null;
/**
* Enforces the usage of the attribute type for the element button
*/
useButtonType?: RuleConfiguration;
useButtonType?: RuleConfiguration_for_Null;
/**
* Enforce that heading elements (h1, h2, etc.) have content and that the content is accessible to screen readers. Accessible means that it is not hidden using the aria-hidden prop.
*/
useHeadingContent?: RuleConfiguration;
useHeadingContent?: RuleConfiguration_for_Null;
/**
* Enforce that html element has lang attribute.
*/
useHtmlLang?: RuleConfiguration;
useHtmlLang?: RuleConfiguration_for_Null;
/**
* Enforces the usage of the attribute title for the element iframe.
*/
useIframeTitle?: RuleConfiguration;
useIframeTitle?: RuleConfiguration_for_Null;
/**
* Enforce onClick is accompanied by at least one of the following: onKeyUp, onKeyDown, onKeyPress.
*/
useKeyWithClickEvents?: RuleConfiguration;
useKeyWithClickEvents?: RuleConfiguration_for_Null;
/**
* Enforce onMouseOver / onMouseOut are accompanied by onFocus / onBlur.
*/
useKeyWithMouseEvents?: RuleConfiguration;
useKeyWithMouseEvents?: RuleConfiguration_for_Null;
/**
* Enforces that audio and video elements must have a track for captions.
*/
useMediaCaption?: RuleConfiguration;
useMediaCaption?: RuleConfiguration_for_Null;
/**
* Enforce that all anchors are valid, and they are navigable elements.
*/
useValidAnchor?: RuleConfiguration;
useValidAnchor?: RuleConfiguration_for_Null;
/**
* Ensures that ARIA properties aria-* are all valid.
*/
useValidAriaProps?: RuleConfiguration;
useValidAriaProps?: RuleConfiguration_for_Null;
/**
* Elements with ARIA roles must use a valid, non-abstract ARIA role.
*/
useValidAriaRole?: RuleConfiguration;
useValidAriaRole?: RuleConfiguration_for_ValidAriaRoleOptions;
/**
* Enforce that ARIA state and property values are valid.
*/
useValidAriaValues?: RuleConfiguration;
useValidAriaValues?: RuleConfiguration_for_Null;
/**
* Ensure that the attribute passed to the lang attribute is a correct ISO language and/or country.
*/
useValidLang?: RuleConfiguration;
useValidLang?: RuleConfiguration_for_Null;
}

@@ -581,71 +595,79 @@ interface Complexity {

*/
noBannedTypes?: RuleConfiguration;
noBannedTypes?: RuleConfiguration_for_Null;
/**
* Disallow empty type parameters in type aliases and interfaces.
*/
noEmptyTypeParameters?: RuleConfiguration_for_Null;
/**
* Disallow functions that exceed a given Cognitive Complexity score.
*/
noExcessiveCognitiveComplexity?: RuleConfiguration;
noExcessiveCognitiveComplexity?: RuleConfiguration_for_ComplexityOptions;
/**
* Disallow unnecessary boolean casts
*/
noExtraBooleanCast?: RuleConfiguration;
noExtraBooleanCast?: RuleConfiguration_for_Null;
/**
* Prefer for...of statement instead of Array.forEach.
*/
noForEach?: RuleConfiguration;
noForEach?: RuleConfiguration_for_Null;
/**
* Disallow unclear usage of consecutive space characters in regular expression literals
*/
noMultipleSpacesInRegularExpressionLiterals?: RuleConfiguration;
noMultipleSpacesInRegularExpressionLiterals?: RuleConfiguration_for_Null;
/**
* This rule reports when a class has no non-static members, such as for a class used exclusively as a static namespace.
*/
noStaticOnlyClass?: RuleConfiguration;
noStaticOnlyClass?: RuleConfiguration_for_Null;
/**
* Disallow this and super in static contexts.
*/
noThisInStatic?: RuleConfiguration;
noThisInStatic?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary catch clauses.
*/
noUselessCatch?: RuleConfiguration;
noUselessCatch?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary constructors.
*/
noUselessConstructor?: RuleConfiguration;
noUselessConstructor?: RuleConfiguration_for_Null;
/**
* Disallow empty exports that don't change anything in a module file.
*/
noUselessEmptyExport?: RuleConfiguration;
noUselessEmptyExport?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary fragments
*/
noUselessFragments?: RuleConfiguration;
noUselessFragments?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary labels.
*/
noUselessLabel?: RuleConfiguration;
noUselessLabel?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary nested block statements.
*/
noUselessLoneBlockStatements?: RuleConfiguration_for_Null;
/**
* Disallow renaming import, export, and destructured assignments to the same name.
*/
noUselessRename?: RuleConfiguration;
noUselessRename?: RuleConfiguration_for_Null;
/**
* Disallow useless case in switch statements.
*/
noUselessSwitchCase?: RuleConfiguration;
noUselessSwitchCase?: RuleConfiguration_for_Null;
/**
* Disallow useless this aliasing.
*/
noUselessThisAlias?: RuleConfiguration;
noUselessThisAlias?: RuleConfiguration_for_Null;
/**
* Disallow using any or unknown as type constraint.
*/
noUselessTypeConstraint?: RuleConfiguration;
noUselessTypeConstraint?: RuleConfiguration_for_Null;
/**
* Disallow the use of void operators, which is not a familiar operator.
*/
noVoid?: RuleConfiguration;
noVoid?: RuleConfiguration_for_Null;
/**
* Disallow with statements in non-strict contexts.
*/
noWith?: RuleConfiguration;
noWith?: RuleConfiguration_for_Null;
/**

@@ -658,27 +680,27 @@ * It enables the recommended rules for this group

*/
useArrowFunction?: RuleConfiguration;
useArrowFunction?: RuleConfiguration_for_Null;
/**
* Promotes the use of .flatMap() when map().flat() are used together.
*/
useFlatMap?: RuleConfiguration;
useFlatMap?: RuleConfiguration_for_Null;
/**
* Enforce the usage of a literal access to properties over computed property access.
*/
useLiteralKeys?: RuleConfiguration;
useLiteralKeys?: RuleConfiguration_for_Null;
/**
* Enforce using concise optional chain instead of chained logical expressions.
*/
useOptionalChain?: RuleConfiguration;
useOptionalChain?: RuleConfiguration_for_Null;
/**
* Enforce the use of the regular expression literals instead of the RegExp constructor if possible.
*/
useRegexLiterals?: RuleConfiguration;
useRegexLiterals?: RuleConfiguration_for_Null;
/**
* Disallow number literal object member names which are not base10 or uses underscore as separator
*/
useSimpleNumberKeys?: RuleConfiguration;
useSimpleNumberKeys?: RuleConfiguration_for_Null;
/**
* Discard redundant terms from logical expressions.
*/
useSimplifiedLogicExpression?: RuleConfiguration;
useSimplifiedLogicExpression?: RuleConfiguration_for_Null;
}

@@ -693,111 +715,123 @@ interface Correctness {

*/
noChildrenProp?: RuleConfiguration;
noChildrenProp?: RuleConfiguration_for_Null;
/**
* Prevents from having const variables being re-assigned.
*/
noConstAssign?: RuleConfiguration;
noConstAssign?: RuleConfiguration_for_Null;
/**
* Disallow constant expressions in conditions
*/
noConstantCondition?: RuleConfiguration;
noConstantCondition?: RuleConfiguration_for_Null;
/**
* Disallow returning a value from a constructor.
*/
noConstructorReturn?: RuleConfiguration;
noConstructorReturn?: RuleConfiguration_for_Null;
/**
* Disallow empty character classes in regular expression literals.
*/
noEmptyCharacterClassInRegex?: RuleConfiguration;
noEmptyCharacterClassInRegex?: RuleConfiguration_for_Null;
/**
* Disallows empty destructuring patterns.
*/
noEmptyPattern?: RuleConfiguration;
noEmptyPattern?: RuleConfiguration_for_Null;
/**
* Disallow calling global object properties as functions
*/
noGlobalObjectCalls?: RuleConfiguration;
noGlobalObjectCalls?: RuleConfiguration_for_Null;
/**
* Disallow function and var declarations that are accessible outside their block.
*/
noInnerDeclarations?: RuleConfiguration;
noInnerDeclarations?: RuleConfiguration_for_Null;
/**
* Prevents the incorrect use of super() inside classes. It also checks whether a call super() is missing from classes that extends other constructors.
*/
noInvalidConstructorSuper?: RuleConfiguration;
noInvalidConstructorSuper?: RuleConfiguration_for_Null;
/**
* Disallow new operators with global non-constructor functions.
*/
noInvalidNewBuiltin?: RuleConfiguration;
noInvalidNewBuiltin?: RuleConfiguration_for_Null;
/**
* Disallow the use of variables and function parameters before their declaration
*/
noInvalidUseBeforeDeclaration?: RuleConfiguration_for_Null;
/**
* Disallow new operators with the Symbol object.
*/
noNewSymbol?: RuleConfiguration;
noNewSymbol?: RuleConfiguration_for_Null;
/**
* Disallow \8 and \9 escape sequences in string literals.
*/
noNonoctalDecimalEscape?: RuleConfiguration;
noNonoctalDecimalEscape?: RuleConfiguration_for_Null;
/**
* Disallow literal numbers that lose precision
*/
noPrecisionLoss?: RuleConfiguration;
noPrecisionLoss?: RuleConfiguration_for_Null;
/**
* Prevent the usage of the return value of React.render.
*/
noRenderReturnValue?: RuleConfiguration;
noRenderReturnValue?: RuleConfiguration_for_Null;
/**
* Disallow assignments where both sides are exactly the same.
*/
noSelfAssign?: RuleConfiguration;
noSelfAssign?: RuleConfiguration_for_Null;
/**
* Disallow returning a value from a setter
*/
noSetterReturn?: RuleConfiguration;
noSetterReturn?: RuleConfiguration_for_Null;
/**
* Disallow comparison of expressions modifying the string case with non-compliant value.
*/
noStringCaseMismatch?: RuleConfiguration;
noStringCaseMismatch?: RuleConfiguration_for_Null;
/**
* Disallow lexical declarations in switch clauses.
*/
noSwitchDeclarations?: RuleConfiguration;
noSwitchDeclarations?: RuleConfiguration_for_Null;
/**
* Prevents the usage of variables that haven't been declared inside the document.
*/
noUndeclaredVariables?: RuleConfiguration;
noUndeclaredVariables?: RuleConfiguration_for_Null;
/**
* Avoid using unnecessary continue.
*/
noUnnecessaryContinue?: RuleConfiguration;
noUnnecessaryContinue?: RuleConfiguration_for_Null;
/**
* Disallow unreachable code
*/
noUnreachable?: RuleConfiguration;
noUnreachable?: RuleConfiguration_for_Null;
/**
* Ensures the super() constructor is called exactly once on every code path in a class constructor before this is accessed if the class has a superclass
*/
noUnreachableSuper?: RuleConfiguration;
noUnreachableSuper?: RuleConfiguration_for_Null;
/**
* Disallow control flow statements in finally blocks.
*/
noUnsafeFinally?: RuleConfiguration;
noUnsafeFinally?: RuleConfiguration_for_Null;
/**
* Disallow the use of optional chaining in contexts where the undefined value is not allowed.
*/
noUnsafeOptionalChaining?: RuleConfiguration;
noUnsafeOptionalChaining?: RuleConfiguration_for_Null;
/**
* Disallow unused imports.
*/
noUnusedImports?: RuleConfiguration_for_Null;
/**
* Disallow unused labels.
*/
noUnusedLabels?: RuleConfiguration;
noUnusedLabels?: RuleConfiguration_for_Null;
/**
* Disallow unused private class members
*/
noUnusedPrivateClassMembers?: RuleConfiguration_for_Null;
/**
* Disallow unused variables.
*/
noUnusedVariables?: RuleConfiguration;
noUnusedVariables?: RuleConfiguration_for_Null;
/**
* This rules prevents void elements (AKA self-closing elements) from having children.
*/
noVoidElementsWithChildren?: RuleConfiguration;
noVoidElementsWithChildren?: RuleConfiguration_for_Null;
/**
* Disallow returning a value from a function with the return type 'void'
*/
noVoidTypeReturn?: RuleConfiguration;
noVoidTypeReturn?: RuleConfiguration_for_Null;
/**

@@ -810,19 +844,19 @@ * It enables the recommended rules for this group

*/
useExhaustiveDependencies?: RuleConfiguration;
useExhaustiveDependencies?: RuleConfiguration_for_HooksOptions;
/**
* Enforce that all React hooks are being called from the Top Level component functions.
*/
useHookAtTopLevel?: RuleConfiguration;
useHookAtTopLevel?: RuleConfiguration_for_DeprecatedHooksOptions;
/**
* Require calls to isNaN() when checking for NaN.
*/
useIsNan?: RuleConfiguration;
useIsNan?: RuleConfiguration_for_Null;
/**
* Enforce "for" loop update clause moving the counter in the right direction.
*/
useValidForDirection?: RuleConfiguration;
useValidForDirection?: RuleConfiguration_for_Null;
/**
* Require generator functions to contain yield.
*/
useYield?: RuleConfiguration;
useYield?: RuleConfiguration_for_Null;
}

@@ -835,53 +869,61 @@ interface Nursery {

/**
* Disallow two keys with the same name inside a JSON object.
* Disallow the use of barrel file.
*/
noDuplicateJsonKeys?: RuleConfiguration;
noBarrelFile?: RuleConfiguration_for_Null;
/**
* Disallow empty block statements and static blocks.
* Disallow the use of console.
*/
noEmptyBlockStatements?: RuleConfiguration;
noConsole?: RuleConfiguration_for_Null;
/**
* Disallow empty type parameters in type aliases and interfaces.
* Disallow two keys with the same name inside a JSON object.
*/
noEmptyTypeParameters?: RuleConfiguration;
noDuplicateJsonKeys?: RuleConfiguration_for_Null;
/**
* Disallow assignments to native objects and read-only global variables.
* A describe block should not contain duplicate hooks.
*/
noGlobalAssign?: RuleConfiguration;
noDuplicateTestHooks?: RuleConfiguration_for_Null;
/**
* Disallow the use of global eval().
* This rule enforces a maximum depth to nested describe() in test files.
*/
noGlobalEval?: RuleConfiguration;
noExcessiveNestedTestSuites?: RuleConfiguration_for_Null;
/**
* Disallow the use of variables and function parameters before their declaration
* Disallow using export or module.exports in files containing tests
*/
noInvalidUseBeforeDeclaration?: RuleConfiguration;
noExportsInTest?: RuleConfiguration_for_Null;
/**
* Disallow characters made with multiple code points in character class syntax.
* Disallow focused tests.
*/
noMisleadingCharacterClass?: RuleConfiguration;
noFocusedTests?: RuleConfiguration_for_Null;
/**
* Disallow the use of namespace imports.
*/
noNamespaceImport?: RuleConfiguration_for_Null;
/**
* Forbid the use of Node.js builtin modules.
*/
noNodejsModules?: RuleConfiguration;
noNodejsModules?: RuleConfiguration_for_Null;
/**
* Disallow then property.
* Avoid re-export all.
*/
noThenProperty?: RuleConfiguration;
noReExportAll?: RuleConfiguration_for_Null;
/**
* Disallow unused imports.
* Disallow specified modules when loaded by import or require.
*/
noUnusedImports?: RuleConfiguration;
noRestrictedImports?: RuleConfiguration_for_RestrictedImportsOptions;
/**
* Disallow unused private class members
* It detects possible "wrong" semicolons inside JSX elements.
*/
noUnusedPrivateClassMembers?: RuleConfiguration;
noSemicolonInJsx?: RuleConfiguration_for_Null;
/**
* Disallow unnecessary nested block statements.
* Disallow disabled tests.
*/
noUselessLoneBlockStatements?: RuleConfiguration;
noSkippedTests?: RuleConfiguration_for_Null;
/**
* Disallow the use of dependencies that aren't specified in the package.json.
*/
noUndeclaredDependencies?: RuleConfiguration_for_Null;
/**
* Disallow ternary operators when simpler alternatives exist.
*/
noUselessTernary?: RuleConfiguration;
noUselessTernary?: RuleConfiguration_for_Null;
/**

@@ -892,45 +934,17 @@ * It enables the recommended rules for this group

/**
* Ensure async functions utilize await.
*/
useAwait?: RuleConfiguration;
/**
* Require consistently using either T[] or Array<T>
*/
useConsistentArrayType?: RuleConfiguration;
/**
* Promotes the use of export type for types.
*/
useExportType?: RuleConfiguration;
/**
* Enforce naming conventions for JavaScript and TypeScript filenames.
*/
useFilenamingConvention?: RuleConfiguration;
/**
* This rule recommends a for-of loop when in a for loop, the index used to extract an item from the iterated array.
*/
useForOf?: RuleConfiguration;
/**
* Enforce the use of import type when an import only has specifiers with type qualifier.
*/
useGroupedTypeImport?: RuleConfiguration;
/**
* Disallows package private imports.
*/
useImportRestrictions?: RuleConfiguration;
useImportRestrictions?: RuleConfiguration_for_Null;
/**
* Promotes the use of import type for types.
* Disallow missing key props in iterators/collection literals.
*/
useImportType?: RuleConfiguration;
useJsxKeyInIterable?: RuleConfiguration_for_Null;
/**
* Enforces using the node: protocol for Node.js builtin modules.
* Promotes the usage of node:assert/strict over node:assert.
*/
useNodejsImportProtocol?: RuleConfiguration;
useNodeAssertStrict?: RuleConfiguration_for_Null;
/**
* Use the Number properties instead of global ones.
* Enforce the sorting of CSS utility classes.
*/
useNumberNamespace?: RuleConfiguration;
/**
* Enforce using function types instead of object type with call signatures.
*/
useShorthandFunctionType?: RuleConfiguration;
useSortedClasses?: RuleConfiguration_for_UtilityClassSortingOptions;
}

@@ -945,7 +959,7 @@ interface Performance {

*/
noAccumulatingSpread?: RuleConfiguration;
noAccumulatingSpread?: RuleConfiguration_for_Null;
/**
* Disallow the use of the delete operator.
*/
noDelete?: RuleConfiguration;
noDelete?: RuleConfiguration_for_Null;
/**

@@ -964,8 +978,12 @@ * It enables the recommended rules for this group

*/
noDangerouslySetInnerHtml?: RuleConfiguration;
noDangerouslySetInnerHtml?: RuleConfiguration_for_Null;
/**
* Report when a DOM element or a component uses both children and dangerouslySetInnerHTML prop.
*/
noDangerouslySetInnerHtmlWithChildren?: RuleConfiguration;
noDangerouslySetInnerHtmlWithChildren?: RuleConfiguration_for_Null;
/**
* Disallow the use of global eval().
*/
noGlobalEval?: RuleConfiguration_for_Null;
/**
* It enables the recommended rules for this group

@@ -983,59 +1001,59 @@ */

*/
noArguments?: RuleConfiguration;
noArguments?: RuleConfiguration_for_Null;
/**
* Disallow comma operator.
*/
noCommaOperator?: RuleConfiguration;
noCommaOperator?: RuleConfiguration_for_Null;
/**
* Disallow default exports.
*/
noDefaultExport?: RuleConfiguration;
noDefaultExport?: RuleConfiguration_for_Null;
/**
* Disallow implicit true values on JSX boolean attributes
*/
noImplicitBoolean?: RuleConfiguration;
noImplicitBoolean?: RuleConfiguration_for_Null;
/**
* Disallow type annotations for variables, parameters, and class properties initialized with a literal expression.
*/
noInferrableTypes?: RuleConfiguration;
noInferrableTypes?: RuleConfiguration_for_Null;
/**
* Disallow the use of TypeScript's namespaces.
*/
noNamespace?: RuleConfiguration;
noNamespace?: RuleConfiguration_for_Null;
/**
* Disallow negation in the condition of an if statement if it has an else clause.
*/
noNegationElse?: RuleConfiguration;
noNegationElse?: RuleConfiguration_for_Null;
/**
* Disallow non-null assertions using the ! postfix operator.
*/
noNonNullAssertion?: RuleConfiguration;
noNonNullAssertion?: RuleConfiguration_for_Null;
/**
* Disallow reassigning function parameters.
*/
noParameterAssign?: RuleConfiguration;
noParameterAssign?: RuleConfiguration_for_Null;
/**
* Disallow the use of parameter properties in class constructors.
*/
noParameterProperties?: RuleConfiguration;
noParameterProperties?: RuleConfiguration_for_Null;
/**
* This rule allows you to specify global variable names that you don’t want to use in your application.
*/
noRestrictedGlobals?: RuleConfiguration;
noRestrictedGlobals?: RuleConfiguration_for_RestrictedGlobalsOptions;
/**
* Disallow the use of constants which its value is the upper-case version of its name.
*/
noShoutyConstants?: RuleConfiguration;
noShoutyConstants?: RuleConfiguration_for_Null;
/**
* Disallow template literals if interpolation and special-character handling are not needed
*/
noUnusedTemplateLiteral?: RuleConfiguration;
noUnusedTemplateLiteral?: RuleConfiguration_for_Null;
/**
* Disallow else block when the if block breaks early.
*/
noUselessElse?: RuleConfiguration;
noUselessElse?: RuleConfiguration_for_Null;
/**
* Disallow the use of var
*/
noVar?: RuleConfiguration;
noVar?: RuleConfiguration_for_Null;
/**

@@ -1048,71 +1066,103 @@ * It enables the recommended rules for this group

*/
useAsConstAssertion?: RuleConfiguration;
useAsConstAssertion?: RuleConfiguration_for_Null;
/**
* Requires following curly brace conventions.
*/
useBlockStatements?: RuleConfiguration;
useBlockStatements?: RuleConfiguration_for_Null;
/**
* Enforce using else if instead of nested if in else clauses.
*/
useCollapsedElseIf?: RuleConfiguration;
useCollapsedElseIf?: RuleConfiguration_for_Null;
/**
* Require consistently using either T[] or Array<T>
*/
useConsistentArrayType?: RuleConfiguration_for_ConsistentArrayTypeOptions;
/**
* Require const declarations for variables that are never reassigned after declared.
*/
useConst?: RuleConfiguration;
useConst?: RuleConfiguration_for_Null;
/**
* Enforce default function parameters and optional function parameters to be last.
*/
useDefaultParameterLast?: RuleConfiguration;
useDefaultParameterLast?: RuleConfiguration_for_Null;
/**
* Require that each enum member value be explicitly initialized.
*/
useEnumInitializers?: RuleConfiguration;
useEnumInitializers?: RuleConfiguration_for_Null;
/**
* Disallow the use of Math.pow in favor of the ** operator.
*/
useExponentiationOperator?: RuleConfiguration;
useExponentiationOperator?: RuleConfiguration_for_Null;
/**
* Promotes the use of export type for types.
*/
useExportType?: RuleConfiguration_for_Null;
/**
* Enforce naming conventions for JavaScript and TypeScript filenames.
*/
useFilenamingConvention?: RuleConfiguration_for_FilenamingConventionOptions;
/**
* This rule recommends a for-of loop when in a for loop, the index used to extract an item from the iterated array.
*/
useForOf?: RuleConfiguration_for_Null;
/**
* This rule enforces the use of <>...</> over <Fragment>...</Fragment>.
*/
useFragmentSyntax?: RuleConfiguration;
useFragmentSyntax?: RuleConfiguration_for_Null;
/**
* Promotes the use of import type for types.
*/
useImportType?: RuleConfiguration_for_Null;
/**
* Require all enum members to be literal values.
*/
useLiteralEnumMembers?: RuleConfiguration;
useLiteralEnumMembers?: RuleConfiguration_for_Null;
/**
* Enforce naming conventions for everything across a codebase.
*/
useNamingConvention?: RuleConfiguration;
useNamingConvention?: RuleConfiguration_for_NamingConventionOptions;
/**
* Enforces using the node: protocol for Node.js builtin modules.
*/
useNodejsImportProtocol?: RuleConfiguration_for_Null;
/**
* Use the Number properties instead of global ones.
*/
useNumberNamespace?: RuleConfiguration_for_Null;
/**
* Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals
*/
useNumericLiterals?: RuleConfiguration;
useNumericLiterals?: RuleConfiguration_for_Null;
/**
* Prevent extra closing tags for components without children
*/
useSelfClosingElements?: RuleConfiguration;
useSelfClosingElements?: RuleConfiguration_for_Null;
/**
* When expressing array types, this rule promotes the usage of T[] shorthand instead of Array<T>.
*/
useShorthandArrayType?: RuleConfiguration;
useShorthandArrayType?: RuleConfiguration_for_Null;
/**
* Require assignment operator shorthand where possible.
*/
useShorthandAssign?: RuleConfiguration;
useShorthandAssign?: RuleConfiguration_for_Null;
/**
* Enforce using function types instead of object type with call signatures.
*/
useShorthandFunctionType?: RuleConfiguration_for_Null;
/**
* Enforces switch clauses have a single statement, emits a quick fix wrapping the statements in a block.
*/
useSingleCaseStatement?: RuleConfiguration;
useSingleCaseStatement?: RuleConfiguration_for_Null;
/**
* Disallow multiple variable declarations in the same variable statement
*/
useSingleVarDeclarator?: RuleConfiguration;
useSingleVarDeclarator?: RuleConfiguration_for_Null;
/**
* Prefer template literals over string concatenation.
*/
useTemplate?: RuleConfiguration;
useTemplate?: RuleConfiguration_for_Null;
/**
* Enforce the use of while loops instead of for loops when the initializer and update expressions are not needed.
*/
useWhile?: RuleConfiguration;
useWhile?: RuleConfiguration_for_Null;
}

@@ -1125,161 +1175,177 @@ interface Suspicious {

/**
* Usually, the definition in the standard library is more precise than what people come up with or the used constant exceeds the maximum precision of the number type.
* Use standard constants instead of approximated literals.
*/
noApproximativeNumericConstant?: RuleConfiguration;
noApproximativeNumericConstant?: RuleConfiguration_for_Null;
/**
* Discourage the usage of Array index in keys.
*/
noArrayIndexKey?: RuleConfiguration;
noArrayIndexKey?: RuleConfiguration_for_Null;
/**
* Disallow assignments in expressions.
*/
noAssignInExpressions?: RuleConfiguration;
noAssignInExpressions?: RuleConfiguration_for_Null;
/**
* Disallows using an async function as a Promise executor.
*/
noAsyncPromiseExecutor?: RuleConfiguration;
noAsyncPromiseExecutor?: RuleConfiguration_for_Null;
/**
* Disallow reassigning exceptions in catch clauses.
*/
noCatchAssign?: RuleConfiguration;
noCatchAssign?: RuleConfiguration_for_Null;
/**
* Disallow reassigning class members.
*/
noClassAssign?: RuleConfiguration;
noClassAssign?: RuleConfiguration_for_Null;
/**
* Prevent comments from being inserted as text nodes
*/
noCommentText?: RuleConfiguration;
noCommentText?: RuleConfiguration_for_Null;
/**
* Disallow comparing against -0
*/
noCompareNegZero?: RuleConfiguration;
noCompareNegZero?: RuleConfiguration_for_Null;
/**
* Disallow labeled statements that are not loops.
*/
noConfusingLabels?: RuleConfiguration;
noConfusingLabels?: RuleConfiguration_for_Null;
/**
* Disallow void type outside of generic or return types.
*/
noConfusingVoidType?: RuleConfiguration;
noConfusingVoidType?: RuleConfiguration_for_Null;
/**
* Disallow the use of console.log
*/
noConsoleLog?: RuleConfiguration;
noConsoleLog?: RuleConfiguration_for_Null;
/**
* Disallow TypeScript const enum
*/
noConstEnum?: RuleConfiguration;
noConstEnum?: RuleConfiguration_for_Null;
/**
* Prevents from having control characters and some escape sequences that match control characters in regular expressions.
*/
noControlCharactersInRegex?: RuleConfiguration;
noControlCharactersInRegex?: RuleConfiguration_for_Null;
/**
* Disallow the use of debugger
*/
noDebugger?: RuleConfiguration;
noDebugger?: RuleConfiguration_for_Null;
/**
* Require the use of === and !==
*/
noDoubleEquals?: RuleConfiguration;
noDoubleEquals?: RuleConfiguration_for_Null;
/**
* Disallow duplicate case labels.
*/
noDuplicateCase?: RuleConfiguration;
noDuplicateCase?: RuleConfiguration_for_Null;
/**
* Disallow duplicate class members.
*/
noDuplicateClassMembers?: RuleConfiguration;
noDuplicateClassMembers?: RuleConfiguration_for_Null;
/**
* Prevents JSX properties to be assigned multiple times.
*/
noDuplicateJsxProps?: RuleConfiguration;
noDuplicateJsxProps?: RuleConfiguration_for_Null;
/**
* Prevents object literals having more than one property declaration for the same name.
*/
noDuplicateObjectKeys?: RuleConfiguration;
noDuplicateObjectKeys?: RuleConfiguration_for_Null;
/**
* Disallow duplicate function parameter name.
*/
noDuplicateParameters?: RuleConfiguration;
noDuplicateParameters?: RuleConfiguration_for_Null;
/**
* Disallow empty block statements and static blocks.
*/
noEmptyBlockStatements?: RuleConfiguration_for_Null;
/**
* Disallow the declaration of empty interfaces.
*/
noEmptyInterface?: RuleConfiguration;
noEmptyInterface?: RuleConfiguration_for_Null;
/**
* Disallow the any type usage.
*/
noExplicitAny?: RuleConfiguration;
noExplicitAny?: RuleConfiguration_for_Null;
/**
* Prevents the wrong usage of the non-null assertion operator (!) in TypeScript files.
*/
noExtraNonNullAssertion?: RuleConfiguration;
noExtraNonNullAssertion?: RuleConfiguration_for_Null;
/**
* Disallow fallthrough of switch clauses.
*/
noFallthroughSwitchClause?: RuleConfiguration;
noFallthroughSwitchClause?: RuleConfiguration_for_Null;
/**
* Disallow reassigning function declarations.
*/
noFunctionAssign?: RuleConfiguration;
noFunctionAssign?: RuleConfiguration_for_Null;
/**
* Disallow assignments to native objects and read-only global variables.
*/
noGlobalAssign?: RuleConfiguration_for_Null;
/**
* Use Number.isFinite instead of global isFinite.
*/
noGlobalIsFinite?: RuleConfiguration;
noGlobalIsFinite?: RuleConfiguration_for_Null;
/**
* Use Number.isNaN instead of global isNaN.
*/
noGlobalIsNan?: RuleConfiguration;
noGlobalIsNan?: RuleConfiguration_for_Null;
/**
* Disallow use of implicit any type on variable declarations.
*/
noImplicitAnyLet?: RuleConfiguration;
noImplicitAnyLet?: RuleConfiguration_for_Null;
/**
* Disallow assigning to imported bindings
*/
noImportAssign?: RuleConfiguration;
noImportAssign?: RuleConfiguration_for_Null;
/**
* Disallow labels that share a name with a variable
*/
noLabelVar?: RuleConfiguration;
noLabelVar?: RuleConfiguration_for_Null;
/**
* Disallow characters made with multiple code points in character class syntax.
*/
noMisleadingCharacterClass?: RuleConfiguration_for_Null;
/**
* Enforce proper usage of new and constructor.
*/
noMisleadingInstantiator?: RuleConfiguration;
noMisleadingInstantiator?: RuleConfiguration_for_Null;
/**
* Disallow shorthand assign when variable appears on both sides.
*/
noMisrefactoredShorthandAssign?: RuleConfiguration;
noMisrefactoredShorthandAssign?: RuleConfiguration_for_Null;
/**
* Disallow direct use of Object.prototype builtins.
*/
noPrototypeBuiltins?: RuleConfiguration;
noPrototypeBuiltins?: RuleConfiguration_for_Null;
/**
* Disallow variable, function, class, and type redeclarations in the same scope.
*/
noRedeclare?: RuleConfiguration;
noRedeclare?: RuleConfiguration_for_Null;
/**
* Prevents from having redundant "use strict".
*/
noRedundantUseStrict?: RuleConfiguration;
noRedundantUseStrict?: RuleConfiguration_for_Null;
/**
* Disallow comparisons where both sides are exactly the same.
*/
noSelfCompare?: RuleConfiguration;
noSelfCompare?: RuleConfiguration_for_Null;
/**
* Disallow identifiers from shadowing restricted names.
*/
noShadowRestrictedNames?: RuleConfiguration;
noShadowRestrictedNames?: RuleConfiguration_for_Null;
/**
* Disallow sparse arrays
*/
noSparseArray?: RuleConfiguration;
noSparseArray?: RuleConfiguration_for_Null;
/**
* Disallow then property.
*/
noThenProperty?: RuleConfiguration_for_Null;
/**
* Disallow unsafe declaration merging between interfaces and classes.
*/
noUnsafeDeclarationMerging?: RuleConfiguration;
noUnsafeDeclarationMerging?: RuleConfiguration_for_Null;
/**
* Disallow using unsafe negation.
*/
noUnsafeNegation?: RuleConfiguration;
noUnsafeNegation?: RuleConfiguration_for_Null;
/**

@@ -1290,23 +1356,31 @@ * It enables the recommended rules for this group

/**
* Ensure async functions utilize await.
*/
useAwait?: RuleConfiguration_for_Null;
/**
* Enforce default clauses in switch statements to be last
*/
useDefaultSwitchClauseLast?: RuleConfiguration;
useDefaultSwitchClauseLast?: RuleConfiguration_for_Null;
/**
* Enforce get methods to always return a value.
*/
useGetterReturn?: RuleConfiguration;
useGetterReturn?: RuleConfiguration_for_Null;
/**
* Use Array.isArray() instead of instanceof Array.
*/
useIsArray?: RuleConfiguration;
useIsArray?: RuleConfiguration_for_Null;
/**
* Require using the namespace keyword over the module keyword to declare TypeScript namespaces.
*/
useNamespaceKeyword?: RuleConfiguration;
useNamespaceKeyword?: RuleConfiguration_for_Null;
/**
* This rule verifies the result of typeof $expr unary expressions is being compared to valid values, either string literals containing valid type names or other typeof expressions
*/
useValidTypeof?: RuleConfiguration;
useValidTypeof?: RuleConfiguration_for_Null;
}
interface OverrideFormatterConfiguration {
/**
* The attribute position style.
*/
attributePosition?: AttributePosition;
enabled?: boolean;

@@ -1354,17 +1428,84 @@ /**

}
type RuleConfiguration = RulePlainConfiguration | RuleWithOptions;
type RuleConfiguration_for_Null =
| RulePlainConfiguration
| RuleWithOptions_for_Null;
type RuleConfiguration_for_ValidAriaRoleOptions =
| RulePlainConfiguration
| RuleWithOptions_for_ValidAriaRoleOptions;
type RuleConfiguration_for_ComplexityOptions =
| RulePlainConfiguration
| RuleWithOptions_for_ComplexityOptions;
type RuleConfiguration_for_HooksOptions =
| RulePlainConfiguration
| RuleWithOptions_for_HooksOptions;
type RuleConfiguration_for_DeprecatedHooksOptions =
| RulePlainConfiguration
| RuleWithOptions_for_DeprecatedHooksOptions;
type RuleConfiguration_for_RestrictedImportsOptions =
| RulePlainConfiguration
| RuleWithOptions_for_RestrictedImportsOptions;
type RuleConfiguration_for_UtilityClassSortingOptions =
| RulePlainConfiguration
| RuleWithOptions_for_UtilityClassSortingOptions;
type RuleConfiguration_for_RestrictedGlobalsOptions =
| RulePlainConfiguration
| RuleWithOptions_for_RestrictedGlobalsOptions;
type RuleConfiguration_for_ConsistentArrayTypeOptions =
| RulePlainConfiguration
| RuleWithOptions_for_ConsistentArrayTypeOptions;
type RuleConfiguration_for_FilenamingConventionOptions =
| RulePlainConfiguration
| RuleWithOptions_for_FilenamingConventionOptions;
type RuleConfiguration_for_NamingConventionOptions =
| RulePlainConfiguration
| RuleWithOptions_for_NamingConventionOptions;
type RulePlainConfiguration = "warn" | "error" | "off";
interface RuleWithOptions {
interface RuleWithOptions_for_Null {
level: RulePlainConfiguration;
options?: PossibleOptions;
options: null;
}
type PossibleOptions =
| ComplexityOptions
| ConsistentArrayTypeOptions
| FilenamingConventionOptions
| HooksOptions
| DeprecatedHooksOptions
| NamingConventionOptions
| RestrictedGlobalsOptions
| ValidAriaRoleOptions;
interface RuleWithOptions_for_ValidAriaRoleOptions {
level: RulePlainConfiguration;
options: ValidAriaRoleOptions;
}
interface RuleWithOptions_for_ComplexityOptions {
level: RulePlainConfiguration;
options: ComplexityOptions;
}
interface RuleWithOptions_for_HooksOptions {
level: RulePlainConfiguration;
options: HooksOptions;
}
interface RuleWithOptions_for_DeprecatedHooksOptions {
level: RulePlainConfiguration;
options: DeprecatedHooksOptions;
}
interface RuleWithOptions_for_RestrictedImportsOptions {
level: RulePlainConfiguration;
options: RestrictedImportsOptions;
}
interface RuleWithOptions_for_UtilityClassSortingOptions {
level: RulePlainConfiguration;
options: UtilityClassSortingOptions;
}
interface RuleWithOptions_for_RestrictedGlobalsOptions {
level: RulePlainConfiguration;
options: RestrictedGlobalsOptions;
}
interface RuleWithOptions_for_ConsistentArrayTypeOptions {
level: RulePlainConfiguration;
options: ConsistentArrayTypeOptions;
}
interface RuleWithOptions_for_FilenamingConventionOptions {
level: RulePlainConfiguration;
options: FilenamingConventionOptions;
}
interface RuleWithOptions_for_NamingConventionOptions {
level: RulePlainConfiguration;
options: NamingConventionOptions;
}
interface ValidAriaRoleOptions {
allowInvalidRoles: string[];
ignoreNonDom: boolean;
}
interface ComplexityOptions {

@@ -1376,2 +1517,31 @@ /**

}
interface HooksOptions {
/**
* List of hooks of which the dependencies should be validated.
*/
hooks: Hook[];
}
interface DeprecatedHooksOptions {}
interface RestrictedImportsOptions {
/**
* A list of names that should trigger the rule
*/
paths: {};
}
interface UtilityClassSortingOptions {
/**
* Additional attributes that will be sorted.
*/
attributes?: string[];
/**
* Names of the functions or tagged templates that will be sorted.
*/
functions?: string[];
}
interface RestrictedGlobalsOptions {
/**
* A list of names that should trigger the rule
*/
deniedGlobals: string[];
}
interface ConsistentArrayTypeOptions {

@@ -1386,2 +1556,6 @@ syntax: ConsistentArrayType;

/**
* If `false`, then non-ASCII characters are allowed.
*/
requireAscii: boolean;
/**
* If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].

@@ -1391,9 +1565,2 @@ */

}
interface HooksOptions {
/**
* List of safe hooks
*/
hooks: Hooks[];
}
interface DeprecatedHooksOptions {}
interface NamingConventionOptions {

@@ -1405,2 +1572,6 @@ /**

/**
* If `false`, then non-ASCII characters are allowed.
*/
requireAscii: boolean;
/**
* If `false`, then consecutive uppercase are allowed in _camel_ and _pascal_ cases. This does not affect other [Case].

@@ -1410,31 +1581,32 @@ */

}
interface RestrictedGlobalsOptions {
interface Hook {
/**
* A list of names that should trigger the rule
*/
deniedGlobals: string[];
}
interface ValidAriaRoleOptions {
allowInvalidRoles: string[];
ignoreNonDom: boolean;
}
type ConsistentArrayType = "shorthand" | "generic";
type FilenameCases = FilenameCase[];
interface Hooks {
/**
* The "position" of the closure function, starting from zero.
### Example
For example, for React's `useEffect()` hook, the closure index is 0.
*/
closureIndex?: number;
/**
* The "position" of the array of dependencies, starting from zero.
* The "position" of the array of dependencies, starting from zero.
For example, for React's `useEffect()` hook, the dependencies index is 1.
*/
dependenciesIndex?: number;
/**
* The name of the hook
* The name of the hook.
*/
name: string;
/**
* Whether the result of the hook is stable.
Set to `true` to mark the identity of the hook's return value as stable, or use a number/an array of numbers to mark the "positions" in the return array as stable.
For example, for React's `useRef()` hook the value would be `true`, while for `useState()` it would be `[1]`.
*/
stableResult: StableHookResult;
}
type ConsistentArrayType = "shorthand" | "generic";
type FilenameCases = FilenameCase[];
type EnumMemberCase = "PascalCase" | "CONSTANT_CASE" | "camelCase";
type StableHookResult = "None" | "Identity" | { Indices: number[] };
type FilenameCase =

@@ -1446,31 +1618,55 @@ | "camelCase"

| "snake_case";
interface ProjectFeaturesParams {
manifest_path: RomePath;
interface UpdateProjectParams {
path: BiomePath;
}
interface ProjectFeaturesResult {}
interface OpenProjectParams {
content: string;
path: BiomePath;
version: number;
}
interface OpenFileParams {
content: string;
language_hint?: Language;
path: RomePath;
document_file_source?: DocumentFileSource;
path: BiomePath;
version: number;
}
type Language =
| "JavaScript"
| "JavaScriptReact"
| "TypeScript"
| "TypeScriptReact"
| "Json"
| "Jsonc"
| "Css"
| "Unknown";
type DocumentFileSource =
| "Unknown"
| { Js: JsFileSource }
| { Json: JsonFileSource }
| { Css: CssFileSource };
interface JsFileSource {
/**
* Used to mark if the source is being used for an Astro, Svelte or Vue file
*/
embedding_kind: EmbeddingKind;
language: Language;
module_kind: ModuleKind;
variant: LanguageVariant;
version: LanguageVersion;
}
interface JsonFileSource {
allow_trailing_comma: boolean;
variant: JsonVariant;
}
interface CssFileSource {
variant: CssVariant;
}
type EmbeddingKind = "Astro" | "Vue" | "Svelte" | "None";
type Language = "JavaScript" | { TypeScript: { definition_file: boolean } };
type ModuleKind = "Script" | "Module";
type LanguageVariant = "Standard" | "StandardRestricted" | "Jsx";
type LanguageVersion = "ES2022" | "ESNext";
type JsonVariant = "Standard" | "Jsonc";
type CssVariant = "Standard";
interface ChangeFileParams {
content: string;
path: RomePath;
path: BiomePath;
version: number;
}
interface CloseFileParams {
path: RomePath;
path: BiomePath;
}
interface GetSyntaxTreeParams {
path: RomePath;
path: BiomePath;
}

@@ -1482,3 +1678,3 @@ interface GetSyntaxTreeResult {

interface OrganizeImportsParams {
path: RomePath;
path: BiomePath;
}

@@ -1489,11 +1685,11 @@ interface OrganizeImportsResult {

interface GetFileContentParams {
path: RomePath;
path: BiomePath;
}
interface GetControlFlowGraphParams {
cursor: TextSize;
path: RomePath;
path: BiomePath;
}
type TextSize = number;
interface GetFormatterIRParams {
path: RomePath;
path: BiomePath;
}

@@ -1503,3 +1699,3 @@ interface PullDiagnosticsParams {

max_diagnostics: number;
path: RomePath;
path: BiomePath;
}

@@ -1559,2 +1755,3 @@ type RuleCategories = RuleCategory[];

| "lint/complexity/noBannedTypes"
| "lint/complexity/noEmptyTypeParameters"
| "lint/complexity/noExcessiveCognitiveComplexity"

@@ -1571,2 +1768,3 @@ | "lint/complexity/noExtraBooleanCast"

| "lint/complexity/noUselessLabel"
| "lint/complexity/noUselessLoneBlockStatements"
| "lint/complexity/noUselessRename"

@@ -1595,2 +1793,3 @@ | "lint/complexity/noUselessSwitchCase"

| "lint/correctness/noInvalidNewBuiltin"
| "lint/correctness/noInvalidUseBeforeDeclaration"
| "lint/correctness/noNewSymbol"

@@ -1610,3 +1809,5 @@ | "lint/correctness/noNonoctalDecimalEscape"

| "lint/correctness/noUnsafeOptionalChaining"
| "lint/correctness/noUnusedImports"
| "lint/correctness/noUnusedLabels"
| "lint/correctness/noUnusedPrivateClassMembers"
| "lint/correctness/noUnusedVariables"

@@ -1621,28 +1822,23 @@ | "lint/correctness/noVoidElementsWithChildren"

| "lint/nursery/noApproximativeNumericConstant"
| "lint/nursery/noBarrelFile"
| "lint/nursery/noConsole"
| "lint/nursery/noDuplicateJsonKeys"
| "lint/nursery/noEmptyBlockStatements"
| "lint/nursery/noEmptyTypeParameters"
| "lint/nursery/noGlobalAssign"
| "lint/nursery/noGlobalEval"
| "lint/nursery/noInvalidUseBeforeDeclaration"
| "lint/nursery/noMisleadingCharacterClass"
| "lint/nursery/noDuplicateTestHooks"
| "lint/nursery/noExcessiveNestedTestSuites"
| "lint/nursery/noExportsInTest"
| "lint/nursery/noFocusedTests"
| "lint/nursery/noNamespaceImport"
| "lint/nursery/noNodejsModules"
| "lint/nursery/noThenProperty"
| "lint/nursery/noReExportAll"
| "lint/nursery/noRestrictedImports"
| "lint/nursery/noSemicolonInJsx"
| "lint/nursery/noSkippedTests"
| "lint/nursery/noTypeOnlyImportAttributes"
| "lint/nursery/noUnusedImports"
| "lint/nursery/noUnusedPrivateClassMembers"
| "lint/nursery/noUselessLoneBlockStatements"
| "lint/nursery/noUndeclaredDependencies"
| "lint/nursery/noUselessTernary"
| "lint/nursery/useAwait"
| "lint/nursery/useBiomeSuppressionComment"
| "lint/nursery/useConsistentArrayType"
| "lint/nursery/useExportType"
| "lint/nursery/useFilenamingConvention"
| "lint/nursery/useForOf"
| "lint/nursery/useGroupedTypeImport"
| "lint/nursery/useImportRestrictions"
| "lint/nursery/useImportType"
| "lint/nursery/useNodejsImportProtocol"
| "lint/nursery/useNumberNamespace"
| "lint/nursery/useShorthandFunctionType"
| "lint/nursery/useJsxKeyInIterable"
| "lint/nursery/useNodeAssertStrict"
| "lint/nursery/useSortedClasses"
| "lint/performance/noAccumulatingSpread"

@@ -1652,2 +1848,3 @@ | "lint/performance/noDelete"

| "lint/security/noDangerouslySetInnerHtmlWithChildren"
| "lint/security/noGlobalEval"
| "lint/style/noArguments"

@@ -1671,2 +1868,3 @@ | "lint/style/noCommaOperator"

| "lint/style/useCollapsedElseIf"
| "lint/style/useConsistentArrayType"
| "lint/style/useConst"

@@ -1676,5 +1874,11 @@ | "lint/style/useDefaultParameterLast"

| "lint/style/useExponentiationOperator"
| "lint/style/useExportType"
| "lint/style/useFilenamingConvention"
| "lint/style/useForOf"
| "lint/style/useFragmentSyntax"
| "lint/style/useImportType"
| "lint/style/useLiteralEnumMembers"
| "lint/style/useNamingConvention"
| "lint/style/useNodejsImportProtocol"
| "lint/style/useNumberNamespace"
| "lint/style/useNumericLiterals"

@@ -1684,2 +1888,3 @@ | "lint/style/useSelfClosingElements"

| "lint/style/useShorthandAssign"
| "lint/style/useShorthandFunctionType"
| "lint/style/useSingleCaseStatement"

@@ -1709,2 +1914,3 @@ | "lint/style/useSingleVarDeclarator"

| "lint/suspicious/noDuplicateParameters"
| "lint/suspicious/noEmptyBlockStatements"
| "lint/suspicious/noEmptyInterface"

@@ -1715,2 +1921,3 @@ | "lint/suspicious/noExplicitAny"

| "lint/suspicious/noFunctionAssign"
| "lint/suspicious/noGlobalAssign"
| "lint/suspicious/noGlobalIsFinite"

@@ -1721,2 +1928,3 @@ | "lint/suspicious/noGlobalIsNan"

| "lint/suspicious/noLabelVar"
| "lint/suspicious/noMisleadingCharacterClass"
| "lint/suspicious/noMisleadingInstantiator"

@@ -1730,4 +1938,6 @@ | "lint/suspicious/noMisrefactoredShorthandAssign"

| "lint/suspicious/noSparseArray"
| "lint/suspicious/noThenProperty"
| "lint/suspicious/noUnsafeDeclarationMerging"
| "lint/suspicious/noUnsafeNegation"
| "lint/suspicious/useAwait"
| "lint/suspicious/useDefaultSwitchClauseLast"

@@ -1834,3 +2044,3 @@ | "lint/suspicious/useGetterReturn"

interface PullActionsParams {
path: RomePath;
path: BiomePath;
range: TextRange;

@@ -1871,3 +2081,3 @@ }

interface FormatFileParams {
path: RomePath;
path: BiomePath;
}

@@ -1891,3 +2101,3 @@ interface Printed {

interface FormatRangeParams {
path: RomePath;
path: BiomePath;
range: TextRange;

@@ -1897,7 +2107,7 @@ }

offset: TextSize;
path: RomePath;
path: BiomePath;
}
interface FixFileParams {
fix_file_mode: FixFileMode;
path: RomePath;
path: BiomePath;
should_format: boolean;

@@ -1936,3 +2146,3 @@ }

new_name: string;
path: RomePath;
path: BiomePath;
symbol_at: TextSize;

@@ -1939,0 +2149,0 @@ }

68

biome_wasm.js

@@ -14,2 +14,11 @@ let imports = {};

function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
function dropObject(idx) {

@@ -27,11 +36,2 @@ if (idx < 132) return;

function addHeapObject(obj) {
if (heap_next === heap.length) heap.push(heap.length + 1);
const idx = heap_next;
heap_next = heap[idx];
heap[idx] = obj;
return idx;
}
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });

@@ -666,16 +666,2 @@

module.exports.__wbindgen_is_undefined = function(arg0) {
const ret = getObject(arg0) === undefined;
return ret;
};
module.exports.__wbindgen_in = function(arg0, arg1) {
const ret = getObject(arg0) in getObject(arg1);
return ret;
};
module.exports.__wbindgen_object_drop_ref = function(arg0) {
takeObject(arg0);
};
module.exports.__wbindgen_boolean_get = function(arg0) {

@@ -702,2 +688,6 @@ const v = getObject(arg0);

module.exports.__wbindgen_object_drop_ref = function(arg0) {
takeObject(arg0);
};
module.exports.__wbindgen_bigint_from_u64 = function(arg0) {

@@ -735,2 +725,7 @@ const ret = BigInt.asUintN(64, arg0);

module.exports.__wbindgen_in = function(arg0, arg1) {
const ret = getObject(arg0) in getObject(arg1);
return ret;
};
module.exports.__wbindgen_is_string = function(arg0) {

@@ -741,5 +736,5 @@ const ret = typeof(getObject(arg0)) === 'string';

module.exports.__wbindgen_object_clone_ref = function(arg0) {
const ret = getObject(arg0);
return addHeapObject(ret);
module.exports.__wbindgen_is_undefined = function(arg0) {
const ret = getObject(arg0) === undefined;
return ret;
};

@@ -752,10 +747,2 @@

module.exports.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
const ret = String(getObject(arg1));
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
getInt32Memory0()[arg0 / 4 + 1] = len0;
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
};
module.exports.__wbindgen_number_new = function(arg0) {

@@ -766,2 +753,7 @@ const ret = arg0;

module.exports.__wbindgen_object_clone_ref = function(arg0) {
const ret = getObject(arg0);
return addHeapObject(ret);
};
module.exports.__wbindgen_string_new = function(arg0, arg1) {

@@ -781,2 +773,10 @@ const ret = getStringFromWasm0(arg0, arg1);

module.exports.__wbg_String_91fba7ded13ba54c = function(arg0, arg1) {
const ret = String(getObject(arg1));
const ptr0 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
const len0 = WASM_VECTOR_LEN;
getInt32Memory0()[arg0 / 4 + 1] = len0;
getInt32Memory0()[arg0 / 4 + 0] = ptr0;
};
module.exports.__wbg_new_abda76e883ba8a5f = function() {

@@ -783,0 +783,0 @@ const ret = new Error();

2

package.json

@@ -1,1 +0,1 @@

{"name":"@biomejs/wasm-nodejs","collaborators":["Biome Developers and Contributors"],"description":"WebAssembly bindings to the Biome workspace API","version":"1.5.3","license":"MIT OR Apache-2.0","repository":{"type":"git","url":"https://github.com/biomejs/biome"},"files":["biome_wasm_bg.wasm","biome_wasm.js","biome_wasm.d.ts"],"main":"biome_wasm.js","homepage":"https://biomejs.dev/","types":"biome_wasm.d.ts","keywords":["parser","linter","formatter"]}
{"name":"@biomejs/wasm-nodejs","collaborators":["Biome Developers and Contributors"],"description":"WebAssembly bindings to the Biome workspace API","version":"1.6.0","license":"MIT OR Apache-2.0","repository":{"type":"git","url":"https://github.com/biomejs/biome"},"files":["biome_wasm_bg.wasm","biome_wasm.js","biome_wasm.d.ts"],"main":"biome_wasm.js","homepage":"https://biomejs.dev/","types":"biome_wasm.d.ts","keywords":["parser","linter","formatter"]}
biome_wasm_bg.wasm

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc