dependency-cruiser 17.3.2 → 17.3.3-beta-2

package/types/restrictions.d.mts

@@ -1,195 +1,195 @@
 import type { DependencyType } from "./shared-types.mjs";
 
 export type MiniDependencyRestrictionType =
-  | string
-  | string[]
-  | {
-      /**
-       * A regular expression or an array of regular expressions the
-       * 'via' module should match to be caught by this rule.
-       */
-      path?: string | string[];
-      /**
-       * A regular expression or an array of regular expressions the
-       * 'via' module should match to be caught by this rule.
-       */
-      pathNot?: string | string[];
-      /**
-       * Which dependency types the dependency between this via and the
-       * previous one in the 'via chain' should have to be caught by
-       * this rule
-       */
-      dependencyTypes?: DependencyType[];
-      /**
-       * Which dependency types the dependency between this via and the
-       * previous one in the 'via chain' should _not_ have to be caught by
-       * this rule
-       */
-      dependencyTypesNot?: DependencyType[];
-    };
+	| string
+	| string[]
+	| {
+			/**
+			 * A regular expression or an array of regular expressions the
+			 * 'via' module should match to be caught by this rule.
+			 */
+			path?: string | string[];
+			/**
+			 * A regular expression or an array of regular expressions the
+			 * 'via' module should match to be caught by this rule.
+			 */
+			pathNot?: string | string[];
+			/**
+			 * Which dependency types the dependency between this via and the
+			 * previous one in the 'via chain' should have to be caught by
+			 * this rule
+			 */
+			dependencyTypes?: DependencyType[];
+			/**
+			 * Which dependency types the dependency between this via and the
+			 * previous one in the 'via chain' should _not_ have to be caught by
+			 * this rule
+			 */
+			dependencyTypesNot?: DependencyType[];
+	  };
 
 export interface IBaseRestrictionType {
-  /**
-   * A regular expression or an array of regular expressions that select
-   * the modules this required rule should apply to.
-   */
-  path?: string | string[];
-  /**
-   * A regular expression or an array of regular expressions that select
-   * the modules this required rule should not apply to (you can use this
-   * to make exceptions on the `path` attribute)
-   */
-  pathNot?: string | string[];
+	/**
+	 * A regular expression or an array of regular expressions that select
+	 * the modules this required rule should apply to.
+	 */
+	path?: string | string[];
+	/**
+	 * A regular expression or an array of regular expressions that select
+	 * the modules this required rule should not apply to (you can use this
+	 * to make exceptions on the `path` attribute)
+	 */
+	pathNot?: string | string[];
 }
 
 export interface IFromRestriction extends IBaseRestrictionType {
-  /**
-   * Whether or not to match when the module is an orphan (= has no incoming and no outgoing
-   * dependencies). When this property it is part of a rule, dependency-cruiser will
-   * ignore the 'to' part.
-   */
-  orphan?: boolean;
+	/**
+	 * Whether or not to match when the module is an orphan (= has no incoming and no outgoing
+	 * dependencies). When this property it is part of a rule, dependency-cruiser will
+	 * ignore the 'to' part.
+	 */
+	orphan?: boolean;
 }
 
 export interface IToRestriction extends IBaseRestrictionType {
-  /**
-   * Whether or not to match modules dependency-cruiser could not resolve (and probably
-   * aren't on disk). For this one too: leave out if you don't care either way.
-   */
-  couldNotResolve?: boolean;
-  /**
-   * Whether or not to match when following to the to will ultimately end up in the from.
-   */
-  circular?: boolean;
-  /**
-   * For circular dependencies - whether or not to match cycles that include
-   * some modules with this regular expression. If you want to match cycles that
-   * _exclusively_ include modules satisfying the regular expression use the viaOnly
-   * restriction.
-   * E.g. to allow all cycles
-   * except when they go through one specific module. Typically to temporarily
-   * disallow some cycles with a lower severity - setting up a rule with a via
-   * that ignores them in an 'allowed' section.
-   */
-  via?: MiniDependencyRestrictionType;
-  /**
-   * "For circular dependencies - whether or not to match cycles that include
-   * exclusively modules with this regular expression. This is different from
-   * the regular via that already matches when only some of the modules in the
-   * cycle satisfy the regular expression
-   */
-  viaOnly?: MiniDependencyRestrictionType;
-  /**
-   * For circular dependencies - whether or not to match cycles that include
-   * _only_ modules that don't satisfy this regular expression. E.g. to disallow all cycles,
-   * except when they go through one specific module. Typically to temporarily
-   * allow some cycles until they're removed.
-   * @deprecated use viaOnly.pathNot in stead
-   */
-  viaNot?: string | string[];
-  /**
-   * "For circular dependencies - whether or not to match cycles that include
-   * _some_ modules that don't satisfy this regular expression.
-   * @deprecated use via.pathNot in stead
-   */
-  viaSomeNot?: string | string[];
-  /**
-   * Whether or not to match when the dependency is a dynamic one.
-   */
-  dynamic?: boolean;
-  /**
-   * Whether or not to match when the dependency is exotically required
-   */
-  exoticallyRequired?: boolean;
-  /**
-   * A regular expression to match against any 'exotic' require strings
-   */
-  exoticRequire?: string | string[];
-  /**
-   * A regular expression to match against any 'exotic' require strings - when it should NOT be caught by the rule
-   */
-  exoticRequireNot?: string | string[];
-  /**
-   * true if this dependency only exists before compilation (like type only imports),
-   * false in all other cases. Only returned when the tsPreCompilationDeps is set to 'specify'.
-   */
-  preCompilationOnly?: boolean;
-  /**
-   * Whether or not to match modules of any of these types (leaving out matches any of them)
-   */
-  dependencyTypes?: DependencyType[];
-  /**
-   * Whether or not to match modules NOT of any of these types (leaving out
-   * matches none of them)"
-   */
-  dependencyTypesNot?: DependencyType[];
-  /**
-   * If true matches dependencies with more than one dependency type (e.g. defined in
-   * _both_ npm and npm-dev)
-   */
-  moreThanOneDependencyType?: boolean;
-  /**
-   * Whether or not to match modules that were released under one of the mentioned
-   * licenses. E.g. to flag GPL-1.0, GPL-2.0 licensed modules (e.g. because your app
-   * is not compatible with the GPL) use "GPL"
-   */
-  license?: string | string[];
-  /**
-   * Whether or not to match modules that were NOT released under one of the mentioned
-   * licenses. E.g. to flag everything non MIT use "MIT" here
-   */
-  licenseNot?: string | string[];
-  /**
-   * When set to true moreUnstable matches for any dependency that has a higher
-   * Instability than the module that depends on it. When set to false it matches
-   * when the opposite is true; the dependency has an equal or lower Instability.
-   *
-   * This attribute is useful when you want to check against Robert C. Martin's
-   * stable dependency * principle. See online documentation for examples and
-   * details.
-   *
-   * Leave this out when you don't care either way.
-   */
-  moreUnstable?: boolean;
-  /**
-   * When set to true, matches when the dependency is in a folder above the " +
-   * folder of the module.
-   */
-  ancestor?: boolean;
+	/**
+	 * Whether or not to match modules dependency-cruiser could not resolve (and probably
+	 * aren't on disk). For this one too: leave out if you don't care either way.
+	 */
+	couldNotResolve?: boolean;
+	/**
+	 * Whether or not to match when following to the to will ultimately end up in the from.
+	 */
+	circular?: boolean;
+	/**
+	 * For circular dependencies - whether or not to match cycles that include
+	 * some modules with this regular expression. If you want to match cycles that
+	 * _exclusively_ include modules satisfying the regular expression use the viaOnly
+	 * restriction.
+	 * E.g. to allow all cycles
+	 * except when they go through one specific module. Typically to temporarily
+	 * disallow some cycles with a lower severity - setting up a rule with a via
+	 * that ignores them in an 'allowed' section.
+	 */
+	via?: MiniDependencyRestrictionType;
+	/**
+	 * "For circular dependencies - whether or not to match cycles that include
+	 * exclusively modules with this regular expression. This is different from
+	 * the regular via that already matches when only some of the modules in the
+	 * cycle satisfy the regular expression
+	 */
+	viaOnly?: MiniDependencyRestrictionType;
+	/**
+	 * For circular dependencies - whether or not to match cycles that include
+	 * _only_ modules that don't satisfy this regular expression. E.g. to disallow all cycles,
+	 * except when they go through one specific module. Typically to temporarily
+	 * allow some cycles until they're removed.
+	 * @deprecated use viaOnly.pathNot in stead
+	 */
+	viaNot?: string | string[];
+	/**
+	 * "For circular dependencies - whether or not to match cycles that include
+	 * _some_ modules that don't satisfy this regular expression.
+	 * @deprecated use via.pathNot in stead
+	 */
+	viaSomeNot?: string | string[];
+	/**
+	 * Whether or not to match when the dependency is a dynamic one.
+	 */
+	dynamic?: boolean;
+	/**
+	 * Whether or not to match when the dependency is exotically required
+	 */
+	exoticallyRequired?: boolean;
+	/**
+	 * A regular expression to match against any 'exotic' require strings
+	 */
+	exoticRequire?: string | string[];
+	/**
+	 * A regular expression to match against any 'exotic' require strings - when it should NOT be caught by the rule
+	 */
+	exoticRequireNot?: string | string[];
+	/**
+	 * true if this dependency only exists before compilation (like type only imports),
+	 * false in all other cases. Only returned when the tsPreCompilationDeps is set to 'specify'.
+	 */
+	preCompilationOnly?: boolean;
+	/**
+	 * Whether or not to match modules of any of these types (leaving out matches any of them)
+	 */
+	dependencyTypes?: DependencyType[];
+	/**
+	 * Whether or not to match modules NOT of any of these types (leaving out
+	 * matches none of them)"
+	 */
+	dependencyTypesNot?: DependencyType[];
+	/**
+	 * If true matches dependencies with more than one dependency type (e.g. defined in
+	 * _both_ npm and npm-dev)
+	 */
+	moreThanOneDependencyType?: boolean;
+	/**
+	 * Whether or not to match modules that were released under one of the mentioned
+	 * licenses. E.g. to flag GPL-1.0, GPL-2.0 licensed modules (e.g. because your app
+	 * is not compatible with the GPL) use "GPL"
+	 */
+	license?: string | string[];
+	/**
+	 * Whether or not to match modules that were NOT released under one of the mentioned
+	 * licenses. E.g. to flag everything non MIT use "MIT" here
+	 */
+	licenseNot?: string | string[];
+	/**
+	 * When set to true moreUnstable matches for any dependency that has a higher
+	 * Instability than the module that depends on it. When set to false it matches
+	 * when the opposite is true; the dependency has an equal or lower Instability.
+	 *
+	 * This attribute is useful when you want to check against Robert C. Martin's
+	 * stable dependency * principle. See online documentation for examples and
+	 * details.
+	 *
+	 * Leave this out when you don't care either way.
+	 */
+	moreUnstable?: boolean;
+	/**
+	 * When set to true, matches when the dependency is in a folder above the " +
+	 * folder of the module.
+	 */
+	ancestor?: boolean;
 }
 
 export interface IReachabilityToRestrictionType extends IBaseRestrictionType {
-  /**
-   * Whether or not to match modules that aren't reachable from the from part of the rule.
-   */
-  reachable: boolean;
+	/**
+	 * Whether or not to match modules that aren't reachable from the from part of the rule.
+	 */
+	reachable: boolean;
 }
 
 export interface IRequiredToRestrictionType {
-  /**
-   * A regular expression or an array of regular expressions at least
-   * one of the dependencies of the module should adhere to.
-   */
-  path?: string | string[];
-  /**
-   * Whether or not to match transitive ('indirect') dependencies as well as direct ones.
-   */
-  reachable?: boolean;
+	/**
+	 * A regular expression or an array of regular expressions at least
+	 * one of the dependencies of the module should adhere to.
+	 */
+	path?: string | string[];
+	/**
+	 * Whether or not to match transitive ('indirect') dependencies as well as direct ones.
+	 */
+	reachable?: boolean;
 }
 
 export interface IDependentsModuleRestrictionType extends IBaseRestrictionType {
-  /**
-   * Matches when the number of times the 'to' module is used falls below (<)
-   * this number. Caveat: only works in concert with path and pathNot restrictions
-   * in the from and to parts of the rule; other conditions will be ignored.
-   * E.g. to flag modules that are used only once or not at all, use 2 here.
-   */
-  numberOfDependentsLessThan?: number;
-  /**
-   * Matches when the number of times the 'to' module is used rises above (<)
-   * this number. Caveat: only works in concert with path and pathNot restrictions
-   * in the from and to parts of the rule; other conditions will be ignored.
-   * E.g. to flag modules that are used more than 10 times, use 10 here.
-   */
-  numberOfDependentsMoreThan?: number;
+	/**
+	 * Matches when the number of times the 'to' module is used falls below (<)
+	 * this number. Caveat: only works in concert with path and pathNot restrictions
+	 * in the from and to parts of the rule; other conditions will be ignored.
+	 * E.g. to flag modules that are used only once or not at all, use 2 here.
+	 */
+	numberOfDependentsLessThan?: number;
+	/**
+	 * Matches when the number of times the 'to' module is used rises above (<)
+	 * this number. Caveat: only works in concert with path and pathNot restrictions
+	 * in the from and to parts of the rule; other conditions will be ignored.
+	 * E.g. to flag modules that are used more than 10 times, use 10 here.
+	 */
+	numberOfDependentsMoreThan?: number;
 }