@ttsc/lint 0.18.4 → 0.19.1

package/src/structures/TtscLintRuleSetting.ts

@@ -27,8 +27,9 @@ export type TtscLintRuleSetting =
   | readonly [TtscLintSeverity];
 
 /**
- * Per-rule severity-plus-options setting for rules that accept a typed options
- * object.
+ * Per-rule severity-plus-options setting for rules that accept one typed
+ * options object. Rules with canonical positional option lists expose a
+ * dedicated setting type instead.
  *
  * This is the tuple form ESLint users know — `[severity, options]` — kept
  * strongly typed by way of the rule's dedicated options interface (see

package/src/structures/format/ITtscLintFormat.ts

@@ -120,8 +120,9 @@ export interface ITtscLintFormat {
   endOfLine?: "lf" | "crlf";
 
   /**
-   * Import sorting & merging. Off unless present; `true` enables it with
-   * defaults, an object customizes.
+   * Import formatting. Off unless present; `true` sorts named specifiers and
+   * erased type-only imports with defaults, and an object customizes behavior.
+   * Runtime declaration reordering requires an explicit unsafe opt-in.
    *
    * @default false
    */

package/src/structures/format/ITtscLintFormatSortImports.ts

@@ -2,9 +2,9 @@
  * Object form of {@link ITtscLintFormat.sortImports}.
  *
  * The declarative {@link order} array expresses group order, blank-line
- * separation, and special groups all by position. Multiple imports of the same
- * module are always merged into one declaration; merging a value import with a
- * type-only import additionally requires {@link combineTypeAndValue}.
+ * separation, and special groups all by position. By default, declaration-level
+ * sorting and merging are limited to erased `import type` blocks. Runtime
+ * imports retain source order unless {@link unsafeSortRuntimeImports} is set.
  */
 export interface ITtscLintFormatSortImports {
   /**
@@ -54,9 +54,26 @@ export interface ITtscLintFormatSortImports {
    * Merge a value import and a type-only import of the same module into one
    * declaration with inline `type` specifiers: `import { foo } from "m"` plus
    * `import type { Bar } from "m"` collapse to `import { foo, type Bar } from
-   * "m"`.
+   * "m"`. Mixed type/value blocks are left unchanged unless
+   * {@link unsafeSortRuntimeImports} is also enabled.
    *
    * @default false
    */
   combineTypeAndValue?: boolean;
+
+  /**
+   * Permit declaration-level sorting and merging of runtime-bearing imports.
+   *
+   * Every default, namespace, named, and bare import can evaluate its module.
+   * Reordering those declarations can therefore change program behavior. Keep
+   * this disabled unless every imported module in the block is
+   * order-independent. Named specifiers inside a declaration and erased `import
+   * type` blocks are still sorted when this option is disabled.
+   *
+   * {@link combineTypeAndValue} only affects mixed type/value blocks when this
+   * option is enabled.
+   *
+   * @default false
+   */
+  unsafeSortRuntimeImports?: boolean;
 }

package/src/structures/rules/ITtscLintBoundariesRuleOptions.ts

@@ -95,23 +95,137 @@ export type ITtscLintBoundariesNoPrivateRuleOptions =
 export type ITtscLintBoundariesNoUnknownRuleOptions =
   ITtscLintBoundariesElementsOptions;
 
+/** One entity selector in a `boundaries/dependencies` policy. */
+export interface ITtscLintBoundariesDependenciesEntitySelectorObject {
+  /** Element type glob(s). */
+  type?: string | readonly string[];
+
+  /** Dependency origin glob(s). */
+  origin?: "local" | "external" | "core" | readonly string[];
+
+  /** Import specifier or source-file glob(s). */
+  source?: string | readonly string[];
+
+  /** Element-local path glob(s). */
+  path?: string | readonly string[];
+
+  /** Whether the selected file is a configured entry file. */
+  entry?: boolean;
+
+  /** Whether the selected file is a configured private file. */
+  private?: boolean;
+
+  /** Whether the local target matched no configured element. */
+  unknown?: boolean;
+}
+
+/** Entity selector or legacy element-type shorthand. */
+export type ITtscLintBoundariesDependenciesEntitySelector =
+  | string
+  | ITtscLintBoundariesDependenciesEntitySelectorObject
+  | readonly (string | ITtscLintBoundariesDependenciesEntitySelectorObject)[];
+
+/** Metadata selector for the import or re-export itself. */
+export interface ITtscLintBoundariesDependenciesInfoSelector {
+  /** TypeScript dependency kind. */
+  kind?: "value" | "type" | "typeof" | readonly ("value" | "type" | "typeof")[];
+
+  /** Import specifier glob(s). */
+  source?: string | readonly string[];
+
+  /** AST dependency kind glob(s), such as `ImportDeclaration`. */
+  nodeKind?: string | readonly string[];
+
+  /** Imported or re-exported name glob(s). */
+  specifiers?: string | readonly string[];
+}
+
+/** Complete dependency selector used by an allow/disallow effect. */
+export interface ITtscLintBoundariesDependenciesSelector {
+  /** Importing entity selector. */
+  from?: ITtscLintBoundariesDependenciesEntitySelector;
+
+  /** Imported entity selector. */
+  to?: ITtscLintBoundariesDependenciesEntitySelector;
+
+  /** Dependency metadata selector. */
+  dependency?:
+    | ITtscLintBoundariesDependenciesInfoSelector
+    | readonly ITtscLintBoundariesDependenciesInfoSelector[];
+}
+
+/** One allow/disallow effect selector. */
+export type ITtscLintBoundariesDependenciesEffect =
+  | ITtscLintBoundariesDependenciesEntitySelector
+  | ITtscLintBoundariesDependenciesSelector
+  | readonly (
+      | string
+      | ITtscLintBoundariesDependenciesEntitySelectorObject
+      | ITtscLintBoundariesDependenciesSelector
+    )[];
+
+/** One ordered `boundaries/dependencies` policy. */
+export interface ITtscLintBoundariesDependenciesPolicy {
+  /** Importing entity selector. Omit to match every configured source. */
+  from?: ITtscLintBoundariesDependenciesEntitySelector;
+
+  /** Imported entity selector. Omit to match every target. */
+  to?: ITtscLintBoundariesDependenciesEntitySelector;
+
+  /** Dependency metadata selector. */
+  dependency?:
+    | ITtscLintBoundariesDependenciesInfoSelector
+    | readonly ITtscLintBoundariesDependenciesInfoSelector[];
+
+  /** Selectors whose matching dependencies are allowed. */
+  allow?: ITtscLintBoundariesDependenciesEffect;
+
+  /** Selectors whose matching dependencies are rejected. */
+  disallow?: ITtscLintBoundariesDependenciesEffect;
+
+  /** Legacy dependency-kind filter; `dependency.kind` takes precedence. */
+  importKind?: "value" | "type" | "typeof";
+
+  /** Optional diagnostic override for this policy. */
+  message?: string;
+}
+
 /**
  * `boundaries/dependencies` rule options.
  *
- * The upstream unified rule subsumes `element-types`, `entry-point`,
- * `external`, `no-private`, and `no-unknown` behind a single direction-aware
- * policy block. The v1 native port registers the rule name and decodes this
- * config shape but does not yet emit diagnostics (`v1 stub; full validation
- * deferred` — see `rules_boundaries.go`).
+ * Policies are evaluated in order and the last matching effect wins. Within one
+ * policy, `disallow` takes precedence over `allow`.
  */
 export interface ITtscLintBoundariesDependenciesRuleOptions extends ITtscLintBoundariesElementsOptions {
   /**
    * Fallback policy when no rule matches.
    *
-   * @default "allow"
+   * @default "disallow"
    */
   default?: "allow" | "disallow";
 
-  /** Ordered dependency policies. First matching policy wins. */
-  rules?: readonly ITtscLintBoundariesElementTypesRule[];
+  /** Ordered dependency policies. Prefer this current upstream name. */
+  policies?: readonly ITtscLintBoundariesDependenciesPolicy[];
+
+  /** Ordered dependency policies; compatibility alias for `policies`. */
+  rules?: readonly ITtscLintBoundariesDependenciesPolicy[];
+
+  /** Evaluate external and `node:` dependencies as well as local targets. */
+  checkAllOrigins?: boolean;
+
+  /** Evaluate local targets that match no configured element. */
+  checkUnknownLocals?: boolean;
+
+  /** Evaluate dependencies within the same configured element root. */
+  checkInternals?: boolean;
+
+  /**
+   * Global diagnostic override.
+   *
+   * Supports `{{from.type}}`, `{{from.path}}`, `{{from.origin}}`,
+   * `{{to.type}}`, `{{to.path}}`, `{{to.origin}}`, `{{dependency.source}}`,
+   * `{{dependency.kind}}`, `{{dependency.nodeKind}}`, and `{{policy.index}}`
+   * placeholders.
+   */
+  message?: string;
 }

package/src/structures/rules/ITtscLintBoundariesRules.ts

@@ -76,16 +76,14 @@ export interface ITtscLintBoundariesRules {
   "boundaries/no-unknown"?: TtscLintRuleOptionsSetting<ITtscLintBoundariesNoUnknownRuleOptions>;
 
   /**
-   * Unified dependency-direction rule from upstream `eslint-plugin-boundaries`,
-   * intended to replace `element-types` / `entry-point` / `external` /
-   * `no-private` / `no-unknown` with a single policy block.
+   * Enforce unified, direction-aware dependency policies.
    *
-   * The native port registers the rule name and accepts the same `elements` +
-   * `rules` config shape as `element-types`, but does not emit diagnostics yet
-   * (v1 stub; full direction validation deferred). Configure it today to claim
-   * the upstream rule id; the legacy split rules continue to enforce policy.
+   * Policies can select the importing and imported element, dependency origin,
+   * resolved path, entry/private/unknown state, import kind, syntax kind, and
+   * imported names. TypeScript path aliases are classified by their resolved
+   * source file rather than by the written specifier.
    *
-   * @reference https://github.com/javierbrea/eslint-plugin-boundaries/blob/master/docs/rules/dependencies.md
+   * @reference https://github.com/javierbrea/eslint-plugin-boundaries/blob/master/packages/website/docs/rules/dependencies.md
    */
   "boundaries/dependencies"?: TtscLintRuleOptionsSetting<ITtscLintBoundariesDependenciesRuleOptions>;
 }

package/src/structures/rules/ITtscLintContributorRules.ts

@@ -7,8 +7,24 @@ import type { TtscLintSeverity } from "../TtscLintSeverity";
  * Plugin authors expose rules under their own namespace prefix (`demo/no-demo`,
  * `myplugin/foo-bar`). The signature here accepts any `"<namespace>/<rule>"`
  * key with either the bare severity form, the severity tuple, or the
- * severity-plus-options tuple. Plugins ship their own typings to tighten the
- * options shape per rule.
+ * severity-plus-options tuple. Plugins tighten a known rule by augmenting
+ * `ITtscLintRuleOptionsMap`; the mapped overlay intersected into
+ * `ITtscLintRules` then supersedes this `unknown` fallback for that key. An
+ * optionless contributor augments this interface directly with
+ * `TtscLintRuleSetting` instead:
+ *
+ * ```ts
+ * import type { TtscLintRuleSetting } from "@ttsc/lint";
+ *
+ * declare module "@ttsc/lint" {
+ *   interface ITtscLintContributorRules {
+ *     "demo/no-options"?: TtscLintRuleSetting;
+ *   }
+ * }
+ * ```
+ *
+ * Contributor namespaces with no imported augmentation retain the compatible
+ * `unknown` options slot.
  *
  * @reference https://ttsc.dev/lint/development/rules
  */