eslint-plugin-ts-fortress 1.0.7 → 1.2.0

package/README.md

@@ -67,9 +67,11 @@ export default [
 
 ## Rules
 
-| Rule                                       | Description                                                                                   |
-| :----------------------------------------- | :-------------------------------------------------------------------------------------------- |
-| `prefer-canonical-length-constrained-type` | Normalize a length-constrained array combinator with degenerate bounds to its canonical form. |
+| Rule                                       | Description                                                                                    |
+| :----------------------------------------- | :--------------------------------------------------------------------------------------------- |
+| `prefer-canonical-length-constrained-type` | Normalize a length-constrained array combinator with degenerate bounds to its canonical form.  |
+| `prefer-namespace-import`                  | Require `ts-fortress` to be imported as a namespace rather than by name.                       |
+| `prefer-schema-over-guard-chain`           | Report a hand-written chain of type guards on one value once it is long enough to be a schema. |
 
 ### `prefer-canonical-length-constrained-type`
 
@@ -133,7 +135,10 @@ bound it carries over to the other combinator is a literal within `0..10`.
 Both the namespace style (`import * as t from 'ts-fortress'`) and named imports
 — including aliases — are recognized, and the autofix reuses whatever binding
 the file already has, adding `import { … } from 'ts-fortress';` only when a
-named call needs one.
+named call needs one. With
+[`prefer-namespace-import`](#prefer-namespace-import) on as well — as it is in
+the `recommended` preset — such an import is rewritten to a namespace access on
+a later fix pass.
 
 #### The rule deliberately leaves alone
 
@@ -149,6 +154,147 @@ named call needs one.
 - calls where the target name is already bound to something else at the call
   site.
 
+### `prefer-namespace-import`
+
+`ts-fortress` is meant to be reached through a namespace. Its exports are short,
+generic names — `string`, `number`, `record`, `array`, `Type` — that collide with
+globals and with local declarations the moment they are pulled into a file's
+scope, and every schema in the wild reads `t.string()`. The rule makes that the
+only spelling:
+
+```ts
+// ❌
+import { record, string } from 'ts-fortress';
+
+const User = record({ name: string() });
+
+// ✅
+import * as t from 'ts-fortress';
+
+const User = t.record({ name: t.string() });
+```
+
+`import type * as t from 'ts-fortress';` is accepted too, and is what the
+autofix writes when every offending import in the file is type-only. A namespace
+import may carry any local name — the rule does not rename an existing one.
+
+A default import is reported as well, and its references become the namespace
+itself. `ts-fortress` has no default export, so such a file did not type-check
+to begin with — the rewrite is what it was reaching for.
+
+A bare `import 'ts-fortress';` is reported and **deleted**: it binds no name,
+and `ts-fortress` declares `sideEffects: false`, so importing it for its own
+sake does nothing.
+
+The autofix rewrites every reference along with the import: aliases resolve back
+to the canonical export (`import { nonEmptyArray as nea }` → `t.nonEmptyArray`),
+shorthand properties are expanded (`{ string }` → `{ string: t.string }`), and
+type positions need nothing special, since `t.Type` reads as a qualified name
+there. Several ts-fortress imports in one file collapse into a single namespace
+import; when the file already has one, the others merge into it under its name.
+
+#### Options
+
+```ts
+'ts-fortress/prefer-namespace-import': ['error', { namespaceName: 'tf' }],
+```
+
+- `namespaceName` (default `'t'`) — the local name the autofix gives the
+  namespace import it creates. A namespace import already in the file is reused
+  under its own name, whatever this is set to.
+
+#### When the fix is withheld
+
+The rule still reports, but leaves the file alone, when the rewrite could not be
+completed safely:
+
+- the namespace name is already bound to something else, at the import or at any
+  reference being rewritten (a fix would silently resolve to that binding);
+- a binding is re-exported by name (`export { string };`), which no member access
+  can spell;
+- a value import would have to merge into an `import type * as t`, which cannot
+  carry it;
+- the file has two namespace imports of `ts-fortress`, or one declaration that
+  mixes a namespace specifier with a named or default one.
+
+### `prefer-schema-over-guard-chain`
+
+A long chain of hand-written type guards is a shape declaration that cannot be
+read as one:
+
+```ts
+// ❌
+const isProject = (value: unknown): value is Project =>
+    isRecord(value) &&
+    hasKey(value, 'name') &&
+    isString(value.name) &&
+    hasKey(value, 'path') &&
+    isString(value.path);
+
+// ✅
+const PROJECT = t.record({ name: t.string(), path: t.string() });
+```
+
+The length is the least of it. What the chain cannot do is say what was wrong:
+it returns `false`, so the caller filtering on it drops the value silently, with
+nothing left of which field was missing or what type it turned out to be. The
+shape is declared and checked in the same breath, so it cannot be named, reused,
+or read on its own. `validate` returns structured `ValidationError`s, ready for
+`validationErrorsToMessages`.
+
+The rule reports; there is no fix. Writing the schema is the work, and it is not
+mechanical — the chain says what the value must _have_, never what it _is_, so
+an optional member, a union, and a member that is simply never checked are
+indistinguishable from the guards alone.
+
+#### What is counted
+
+Guards within one `&&` chain, or one `||` chain of negated guards — the
+early-return spelling of the same check — grouped by the identifier their first
+argument is rooted at, so `hasKey(a, 'b')` and `isString(a.b)` count together
+while guards on two different values do not add up.
+
+A whole function body is deliberately not the unit. The same value checked once
+per field across a `fill`-style function is a series of defaults rather than a
+shape check, and measuring both units over one repository showed those to be
+almost all of what a function-scoped count reports.
+
+#### Options
+
+```ts
+'ts-fortress/prefer-schema-over-guard-chain': ['error', { threshold: 4 }],
+```
+
+- `threshold` (default `5`) — how many guards on one value a single chain may
+  contain before it is reported.
+- `guards` (default: the `ts-data-forge` narrowing helpers — `hasKey`,
+  `isRecord`, `isString`, `isNumber`, `isBoolean`, `isBigint`, `isSymbol`,
+  `isArray`, `isNonEmpty`, `isNonNullish`, `isNotNull`, `isNotUndefined`,
+  `isPrimitive`) — the names to count, replacing the default list. A member call
+  is matched on its property name, so `Arr.isArray` is named `isArray`.
+
+The default threshold comes from a distribution rather than from taste. Counted
+over the 3420 files of the repository this rule was written in, as they stood
+before it was applied to them:
+
+| guards | chains |
+| -----: | -----: |
+|      1 |    103 |
+|      2 |     41 |
+|      3 |     17 |
+|      4 |      1 |
+|      5 |      1 |
+|     6+ |      0 |
+
+One and two are ordinary narrowing and reporting them would be noise; three is
+still common enough to be a style rather than a smell. Four and five have one
+chain each, and they differ in exactly the way the threshold has to: the chain
+of four narrows a value that is already typed, which is the case this rule is
+least interested in, while the chain of five narrows the result of a
+`JSON.parse` — the case it exists for. So the default sits between them, at the
+length of the chain that prompted the rule. That chain of five is the one site
+the rule reported when it was turned on, and it has since been rewritten.
+
 ## License
 
 [Apache-2.0](https://github.com/noshiro-pf/mono/blob/main/libs/eslint-plugin-ts-fortress/LICENSE)

package/dist/index.mjs

@@ -1,3 +1,3 @@
 export { eslintPluginTsFortress } from './plugin.mjs';
-export { tsFortressRules } from './rules/rules.mjs';
-//# sourceMappingURL=index.mjs.map
+export { tsFortressRules } from './rules/index.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../src/index.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAKtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/plugin.d.mts

@@ -5,6 +5,13 @@ export declare const eslintPluginTsFortress: {
     };
     readonly rules: {
         readonly 'prefer-canonical-length-constrained-type': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useCanonicalType", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        readonly 'prefer-namespace-import': import("@typescript-eslint/utils/ts-eslint").RuleModule<"removeSideEffectImport" | "useNamespaceImport", readonly [(Readonly<{
+            namespaceName?: string;
+        }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        readonly 'prefer-schema-over-guard-chain': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferSchema", readonly [(Readonly<{
+            threshold?: number;
+            guards?: readonly string[];
+        }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     };
     readonly configs: {
         /** Enables every rule of this plugin at `error`. */
@@ -15,6 +22,8 @@ export declare const eslintPluginTsFortress: {
             };
             readonly rules: {
                 readonly 'ts-fortress/prefer-canonical-length-constrained-type': 'error';
+                readonly 'ts-fortress/prefer-namespace-import': 'error';
+                readonly 'ts-fortress/prefer-schema-over-guard-chain': 'error';
             };
         };
     };

package/dist/plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AA+BvE,eAAO,MAAM,sBAAsB;;iBAE/B,IAAI,EAAE,2BAA2B;;;;;;QAIjC,oDAAoD;iBACpD,WAAW;2BAtBP,yBAAyB;;yBAQzB,aAAa,EAAI,YAAY;;;iFAfqB,OAAO;;;;CA+BhC,CAAC"}
+{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAiCvE,eAAO,MAAM,sBAAsB;;iBAE/B,IAAI,EAAE,2BAA2B;;;;;;;;;;;;;QAIjC,oDAAoD;iBACpD,WAAW;2BAtBP,yBAAyB;;yBAQzB,aAAa,EAAI,YAAY;;;iFAjBqB,OAAO;gEACxB,OAAO;uEACA,OAAO;;;;CA+BtB,CAAC"}

package/dist/plugin.mjs

@@ -1,33 +1,38 @@
-import { tsFortressRules } from './rules/rules.mjs';
+import { tsFortressRules } from './rules/index.mjs';
+
+
+
+
+
 
 const recommendedRules = {
-  "ts-fortress/prefer-canonical-length-constrained-type": "error"
+    'ts-fortress/prefer-canonical-length-constrained-type': 'error',
+    'ts-fortress/prefer-namespace-import': 'error',
+    'ts-fortress/prefer-schema-over-guard-chain': 'error',
 };
 const recommendedConfig = {
-  name: "ts-fortress/recommended",
-  plugins: {
-    // Resolved lazily so that this config registers the *same* object that
-    // `eslintPluginTsFortress` refers to. ESLint rejects a plugin name that
-    // maps to two different objects with `Cannot redefine plugin`, which is
-    // what a user combining this preset with their own
-    // `plugins: { 'ts-fortress': eslintPluginTsFortress }` entry would hit if
-    // the preset embedded a separate copy of the plugin.
-    get "ts-fortress"() {
-      return eslintPluginTsFortress;
-    }
-  },
-  rules: recommendedRules
-};
-const eslintPluginTsFortress = {
-  meta: {
-    name: "eslint-plugin-ts-fortress"
-  },
-  rules: tsFortressRules,
-  configs: {
-    /** Enables every rule of this plugin at `error`. */
-    recommended: recommendedConfig
-  }
+    name: 'ts-fortress/recommended',
+    plugins: {
+
+
+
+
+
+
+        get 'ts-fortress'() {
+            return eslintPluginTsFortress;
+        },
+    },
+    rules: recommendedRules,
 };
+export const eslintPluginTsFortress = {
+    meta: {
+        name: 'eslint-plugin-ts-fortress',
+    },
+    rules: tsFortressRules,
+    configs: {
 
-export { eslintPluginTsFortress };
-//# sourceMappingURL=plugin.mjs.map
+        recommended: recommendedConfig,
+    },
+};
+//# sourceMappingURL=plugin.mjs.map

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.mjs","sources":["../src/plugin.mts"],"sourcesContent":["import { type ReadonlyRecord } from 'ts-type-forge';\nimport { tsFortressRules } from './rules/index.mjs';\nimport { type ESLintFlatConfig, type ESLintPlugin } from './types.mjs';\n\n/**\n * Every rule this plugin ships, at `error`.\n *\n * The `satisfies` clause below is keyed off {@link tsFortressRules}, so adding\n * a rule without listing it here fails to type-check.\n */\nconst recommendedRules = {\n  'ts-fortress/prefer-canonical-length-constrained-type': 'error',\n} as const satisfies ReadonlyRecord<\n  `ts-fortress/${keyof typeof tsFortressRules}`,\n  'error'\n>;\n\nconst recommendedConfig = {\n  name: 'ts-fortress/recommended',\n  plugins: {\n    // Resolved lazily so that this config registers the *same* object that\n    // `eslintPluginTsFortress` refers to. ESLint rejects a plugin name that\n    // maps to two different objects with `Cannot redefine plugin`, which is\n    // what a user combining this preset with their own\n    // `plugins: { 'ts-fortress': eslintPluginTsFortress }` entry would hit if\n    // the preset embedded a separate copy of the plugin.\n    get 'ts-fortress'(): ESLintPlugin {\n      return eslintPluginTsFortress;\n    },\n  },\n  rules: recommendedRules,\n} as const satisfies ESLintFlatConfig;\n\nexport const eslintPluginTsFortress = {\n  meta: {\n    name: 'eslint-plugin-ts-fortress',\n  },\n  rules: tsFortressRules,\n  configs: {\n    /** Enables every rule of this plugin at `error`. */\n    recommended: recommendedConfig,\n  },\n} as const satisfies ESLintPlugin;\n"],"names":[],"mappings":";;AAUA,MAAM,gBAAA,GAAmB;AAAA,EACvB,sDAAA,EAAwD;AAC1D,CAAA;AAKA,MAAM,iBAAA,GAAoB;AAAA,EACxB,IAAA,EAAM,yBAAA;AAAA,EACN,OAAA,EAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOP,IAAI,aAAA,GAA8B;AAChC,MAAA,OAAO,sBAAA;AAAA,IACT;AAAA,GACF;AAAA,EACA,KAAA,EAAO;AACT,CAAA;AAEO,MAAM,sBAAA,GAAyB;AAAA,EACpC,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM;AAAA,GACR;AAAA,EACA,KAAA,EAAO,eAAA;AAAA,EACP,OAAA,EAAS;AAAA;AAAA,IAEP,WAAA,EAAa;AAAA;AAEjB;;;;"}
+{"version":3,"file":"plugin.mjs","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG;IACvB,sDAAsD,EAAE,OAAO;IAC/D,qCAAqC,EAAE,OAAO;IAC9C,4CAA4C,EAAE,OAAO;CAItD,CAAC;AAEF,MAAM,iBAAiB,GAAG;IACxB,IAAI,EAAE,yBAAyB;IAC/B,OAAO,EAAE;QACP,uEAAuE;QACvE,wEAAwE;QACxE,wEAAwE;QACxE,mDAAmD;QACnD,0EAA0E;QAC1E,qDAAqD;QACrD,IAAI,aAAa;YACf,OAAO,sBAAsB,CAAC;QAChC,CAAC;KACF;IACD,KAAK,EAAE,gBAAgB;CACY,CAAC;AAEtC,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,IAAI,EAAE;QACJ,IAAI,EAAE,2BAA2B;KAClC;IACD,KAAK,EAAE,eAAe;IACtB,OAAO,EAAE;QACP,oDAAoD;QACpD,WAAW,EAAE,iBAAiB;KAC/B;CAC8B,CAAC"}

package/dist/rule-types.d.mts

@@ -1,6 +1,14 @@
+import { type TSESLint } from '@typescript-eslint/utils';
 import { type Linter } from 'eslint';
-import { type ReadonlyRecord, type TypeEq } from 'ts-type-forge';
+import { type TypeEq } from 'ts-type-forge';
 import { type tsFortressRules } from './rules/index.mjs';
+type SpreadOptionsIfIsArray<T extends readonly [Linter.StringSeverity, unknown]> = T[1] extends readonly unknown[] ? readonly [Linter.StringSeverity, ...T[1]] : T;
+/**
+ * Extracts the options tuple type of a rule from its TypeScript
+ * implementation, so that option types stay in sync with the rule source
+ * without converting `meta.schema` (JSON Schema) back into TypeScript types.
+ */
+type RuleOptionsOf<Name extends keyof typeof tsFortressRules> = (typeof tsFortressRules)[Name] extends TSESLint.RuleModule<infer _MessageIds extends string, infer Options extends readonly unknown[]> ? Options : never;
 /**
  * @description Normalize a length-constrained ts-fortress array combinator whose bounds are degenerate (e.g. `minLengthArray(1, x)`, `boundedLengthTuple(n, n, x)`) to the combinator that names that constraint directly.
  *
@@ -15,10 +23,90 @@ import { type tsFortressRules } from './rules/index.mjs';
 declare namespace PreferCanonicalLengthConstrainedType {
     type RuleEntry = Linter.StringSeverity;
 }
+/**
+ * @description Require `ts-fortress` to be imported as a namespace (`import * as t from 'ts-fortress';` or `import type * as t from 'ts-fortress';`) rather than through named, default or bare side-effect imports.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | code       |
+ *  ```
+ */
+declare namespace PreferNamespaceImport {
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "namespaceName": {
+     *         "type": "string",
+     *         "pattern": "^[$A-Z_a-z][$\\w]*$",
+     *         "description": "Local name the autofix gives the namespace import when the file has none to merge into. Defaults to 't'. A namespace import already in the file is reused under its own name, whatever this is set to."
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'prefer-namespace-import'>[0]>;
+    type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
+/**
+ * @description Report a chain of hand-written type guards narrowing one value, once it is long enough to be a schema, and point at `ts-fortress`
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | false      |
+ *  ```
+ */
+declare namespace PreferSchemaOverGuardChain {
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "threshold": {
+     *         "type": "integer",
+     *         "minimum": 2,
+     *         "description": "How many guards on one value a single chain may contain before it is reported. Defaults to 5."
+     *       },
+     *       "guards": {
+     *         "type": "array",
+     *         "items": {
+     *           "type": "string"
+     *         },
+     *         "description": "Names of the guard functions to count, replacing the default list. A member call is matched on its property name, so `Arr.isArray` is named `isArray`."
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'prefer-schema-over-guard-chain'>[0]>;
+    type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
 export type EslintTsFortressRules = Readonly<{
     'ts-fortress/prefer-canonical-length-constrained-type': PreferCanonicalLengthConstrainedType.RuleEntry;
+    'ts-fortress/prefer-namespace-import': PreferNamespaceImport.RuleEntry;
+    'ts-fortress/prefer-schema-over-guard-chain': PreferSchemaOverGuardChain.RuleEntry;
+}>;
+export type EslintTsFortressRulesOption = Readonly<{
+    'ts-fortress/prefer-namespace-import': PreferNamespaceImport.Options;
+    'ts-fortress/prefer-schema-over-guard-chain': PreferSchemaOverGuardChain.Options;
 }>;
-export type EslintTsFortressRulesOption = ReadonlyRecord<never, never>;
 type AssertTrue<B extends true> = B;
 export type RuleNamesAreInSync = AssertTrue<TypeEq<keyof EslintTsFortressRules, `ts-fortress/${keyof typeof tsFortressRules}`>>;
 export {};

package/dist/rule-types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;;;;;;;;GAUG;AACH,kBAAU,oCAAoC,CAAC;IAC7C,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,sDAAsD,EAAE,oCAAoC,CAAC,SAAS,CAAC;CACxG,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAIvE,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,qBAAqB,EAC3B,eAAe,MAAM,OAAO,eAAe,EAAE,CAC9C,CACF,CAAC"}
+{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD,KAAK,sBAAsB,CACzB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,IACjD,CAAC,CAAC,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,GAC/B,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GACzC,CAAC,CAAC;AAEN;;;;GAIG;AACH,KAAK,aAAa,CAAC,IAAI,SAAS,MAAM,OAAO,eAAe,IAC1D,CAAC,OAAO,eAAe,CAAC,CAAC,IAAI,CAAC,SAAS,QAAQ,CAAC,UAAU,CACxD,MAAM,WAAW,SAAS,MAAM,EAChC,MAAM,OAAO,SAAS,SAAS,OAAO,EAAE,CACzC,GACG,OAAO,GACP,KAAK,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,kBAAU,oCAAoC,CAAC;IAC7C,KAAY,SAAS,GAAG,MAAM,CAAC,cAAc,CAAC;CAC/C;AAED;;;;;;;;;;GAUG;AACH,kBAAU,qBAAqB,CAAC;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAY,OAAO,GAAG,WAAW,CAC/B,aAAa,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAC5C,CAAC;IAEF,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED;;;;;;;;;;GAUG;AACH,kBAAU,0BAA0B,CAAC;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAY,OAAO,GAAG,WAAW,CAC/B,aAAa,CAAC,gCAAgC,CAAC,CAAC,CAAC,CAAC,CACnD,CAAC;IAEF,KAAY,SAAS,GACjB,KAAK,GACL,MAAM,CAAC,QAAQ,GACf,sBAAsB,CAAC,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC,CAAC;CACvE;AAED,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,sDAAsD,EAAE,oCAAoC,CAAC,SAAS,CAAC;IACvG,qCAAqC,EAAE,qBAAqB,CAAC,SAAS,CAAC;IACvE,4CAA4C,EAAE,0BAA0B,CAAC,SAAS,CAAC;CACpF,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC;IACjD,qCAAqC,EAAE,qBAAqB,CAAC,OAAO,CAAC;IACrE,4CAA4C,EAAE,0BAA0B,CAAC,OAAO,CAAC;CAClF,CAAC,CAAC;AAIH,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC;AAEpC,MAAM,MAAM,kBAAkB,GAAG,UAAU,CACzC,MAAM,CACJ,MAAM,qBAAqB,EAC3B,eAAe,MAAM,OAAO,eAAe,EAAE,CAC9C,CACF,CAAC"}

package/dist/rule-types.mjs

@@ -1,2 +1,3 @@
 
-//# sourceMappingURL=rule-types.mjs.map
+export {};
+//# sourceMappingURL=rule-types.mjs.map

package/dist/rule-types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"rule-types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"rule-types.mjs","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"AAAA,oBAAoB"}

package/dist/rules/constants.mjs

@@ -1,12 +1,17 @@
-const TS_FORTRESS_MODULE = "ts-fortress";
-const ARRAY_FN = "array";
-const BOUNDED_LENGTH_TUPLE_FN = "boundedLengthTuple";
-const FIXED_LENGTH_TUPLE_FN = "fixedLengthTuple";
-const MAX_LENGTH_TUPLE_FN = "maxLengthTuple";
-const MIN_LENGTH_ARRAY_FN = "minLengthArray";
-const MIN_LENGTH_TUPLE_FN = "minLengthTuple";
-const NON_EMPTY_ARRAY_FN = "nonEmptyArray";
-const STRUCTURAL_PREFIX_CAP = 10;
-
-export { ARRAY_FN, BOUNDED_LENGTH_TUPLE_FN, FIXED_LENGTH_TUPLE_FN, MAX_LENGTH_TUPLE_FN, MIN_LENGTH_ARRAY_FN, MIN_LENGTH_TUPLE_FN, NON_EMPTY_ARRAY_FN, STRUCTURAL_PREFIX_CAP, TS_FORTRESS_MODULE };
-//# sourceMappingURL=constants.mjs.map
+export const TS_FORTRESS_MODULE = 'ts-fortress';
+export const ARRAY_FN = 'array';
+export const BOUNDED_LENGTH_TUPLE_FN = 'boundedLengthTuple';
+export const FIXED_LENGTH_TUPLE_FN = 'fixedLengthTuple';
+export const MAX_LENGTH_TUPLE_FN = 'maxLengthTuple';
+export const MIN_LENGTH_ARRAY_FN = 'minLengthArray';
+export const MIN_LENGTH_TUPLE_FN = 'minLengthTuple';
+export const NON_EMPTY_ARRAY_FN = 'nonEmptyArray';
+
+
+
+
+
+
+
+export const STRUCTURAL_PREFIX_CAP = 10;
+//# sourceMappingURL=constants.mjs.map

package/dist/rules/constants.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"constants.mjs","sources":["../../src/rules/constants.mts"],"sourcesContent":["export const TS_FORTRESS_MODULE = 'ts-fortress';\n\nexport const ARRAY_FN = 'array';\n\nexport const BOUNDED_LENGTH_TUPLE_FN = 'boundedLengthTuple';\n\nexport const FIXED_LENGTH_TUPLE_FN = 'fixedLengthTuple';\n\nexport const MAX_LENGTH_TUPLE_FN = 'maxLengthTuple';\n\nexport const MIN_LENGTH_ARRAY_FN = 'minLengthArray';\n\nexport const MIN_LENGTH_TUPLE_FN = 'minLengthTuple';\n\nexport const NON_EMPTY_ARRAY_FN = 'nonEmptyArray';\n\n/**\n * Inclusive upper bound of ts-type-forge's `StructuralPrefixLength` (`0..10`) —\n * the lengths the structural `*Tuple` combinators encode in their result type.\n * A bound outside this range selects a different overload (one that drops the\n * constraint), so a rewrite that carries a bound over to another combinator\n * only stays type-identical while the bound is within it.\n */\nexport const STRUCTURAL_PREFIX_CAP = 10;\n"],"names":[],"mappings":"AAAO,MAAM,kBAAA,GAAqB;AAE3B,MAAM,QAAA,GAAW;AAEjB,MAAM,uBAAA,GAA0B;AAEhC,MAAM,qBAAA,GAAwB;AAE9B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,mBAAA,GAAsB;AAE5B,MAAM,kBAAA,GAAqB;AAS3B,MAAM,qBAAA,GAAwB;;;;"}
+{"version":3,"file":"constants.mjs","sourceRoot":"","sources":["../../src/rules/constants.mts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,kBAAkB,GAAG,aAAa,CAAC;AAEhD,MAAM,CAAC,MAAM,QAAQ,GAAG,OAAO,CAAC;AAEhC,MAAM,CAAC,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;AAE5D,MAAM,CAAC,MAAM,qBAAqB,GAAG,kBAAkB,CAAC;AAExD,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAEpD,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAEpD,MAAM,CAAC,MAAM,mBAAmB,GAAG,gBAAgB,CAAC;AAEpD,MAAM,CAAC,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC"}

package/dist/rules/import-utils.mjs

@@ -1,58 +1,102 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import { TS_FORTRESS_MODULE } from './constants.mjs';
 
-const getTsFortressImports = (program) => program.body.filter(
-  (node) => node.type === AST_NODE_TYPES.ImportDeclaration && node.source.value === TS_FORTRESS_MODULE
-);
-const getImportedLocalName = (importDeclarations, importedName) => importDeclarations.flatMap((declaration) => declaration.specifiers).find(
-  (specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value) === importedName
-)?.local.name;
-const buildCalleeResolver = (importDeclarations) => {
-  const specifiers = importDeclarations.flatMap(
-    (declaration) => declaration.specifiers
-  );
-  const namespaceNames = new Set(
-    specifiers.filter(
-      (specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier
-    ).map((specifier) => specifier.local.name)
-  );
-  const localToCanonical = new Map(
-    specifiers.flatMap((specifier) => {
-      if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) return [];
-      const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier ? specifier.imported.name : specifier.imported.value;
-      return typeof importedName === "string" ? [[specifier.local.name, importedName]] : [];
-    })
-  );
-  return (callee) => {
-    if (callee.type === AST_NODE_TYPES.Identifier) {
-      const canonicalName = localToCanonical.get(callee.name);
-      return canonicalName === void 0 ? void 0 : { canonicalName, propertyNode: callee, isNamespace: false };
-    }
-    return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES.Identifier && namespaceNames.has(callee.object.name) && callee.property.type === AST_NODE_TYPES.Identifier ? {
-      canonicalName: callee.property.name,
-      propertyNode: callee.property,
-      isNamespace: true
-    } : void 0;
-  };
+export const getTsFortressImports = (program) => program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
+    node.source.value === TS_FORTRESS_MODULE);
+
+
+
+
+
+
+export const getImportedLocalName = (importDeclarations, importedName) => importDeclarations
+    .flatMap((declaration) => declaration.specifiers)
+    .find((specifier) => specifier.type === AST_NODE_TYPES.ImportSpecifier &&
+    (specifier.imported.type === AST_NODE_TYPES.Identifier
+        ? specifier.imported.name
+        : specifier.imported.value) === importedName)?.local.name;
+
+
+
+
+
+
+
+export const buildCalleeResolver = (importDeclarations) => {
+    const specifiers = importDeclarations.flatMap((declaration) => declaration.specifiers);
+    const namespaceNames = new Set(specifiers
+        .filter((specifier) => specifier.type === AST_NODE_TYPES.ImportNamespaceSpecifier)
+        .map((specifier) => specifier.local.name));
+    const localToCanonical = new Map(specifiers.flatMap((specifier) => {
+        if (specifier.type !== AST_NODE_TYPES.ImportSpecifier)
+            return [];
+        const importedName = specifier.imported.type === AST_NODE_TYPES.Identifier
+            ? specifier.imported.name
+            : specifier.imported.value;
+        return typeof importedName === 'string'
+            ? [[specifier.local.name, importedName]]
+            : [];
+    }));
+    return (callee) => {
+        if (callee.type === AST_NODE_TYPES.Identifier) {
+            const canonicalName = localToCanonical.get(callee.name);
+            return canonicalName === undefined
+                ? undefined
+                : { canonicalName, propertyNode: callee, isNamespace: false };
+        }
+        return callee.type === AST_NODE_TYPES.MemberExpression &&
+            !callee.computed &&
+            callee.object.type === AST_NODE_TYPES.Identifier &&
+            namespaceNames.has(callee.object.name) &&
+            callee.property.type === AST_NODE_TYPES.Identifier
+            ? {
+                canonicalName: callee.property.name,
+                propertyNode: callee.property,
+                isNamespace: true,
+            }
+            : undefined;
+    };
 };
-const hasForeignBinding = (sourceCode, node, name) => {
-  for (let mut_scope = sourceCode.getScope(node); mut_scope !== null; mut_scope = mut_scope.upper) {
-    const variable = mut_scope.set.get(name);
-    if (variable !== void 0) {
-      return variable.defs.some((def) => !isTsFortressImportDef(def.node));
+
+
+
+
+
+
+
+
+
+export const hasForeignBinding = (sourceCode, node, name) => {
+    for (let mut_scope = sourceCode.getScope(node); mut_scope !== null; mut_scope = mut_scope.upper) {
+        const variable = mut_scope.set.get(name);
+
+
+        if (variable !== undefined) {
+            return variable.defs.some((def) => !isTsFortressImportDef(def.node));
+        }
     }
-  }
-  return false;
+    return false;
 };
-const buildImportsFix = (fixer, program, names) => Arr.isEmpty(names) ? [] : [
-  fixer.insertTextBefore(
-    program,
-    names.map((name) => `import { ${name} } from '${TS_FORTRESS_MODULE}';
-`).join("")
-  )
-];
-const isTsFortressImportDef = (node) => (node.type === AST_NODE_TYPES.ImportSpecifier || node.type === AST_NODE_TYPES.ImportDefaultSpecifier || node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) && node.parent.type === AST_NODE_TYPES.ImportDeclaration && node.parent.source.value === TS_FORTRESS_MODULE;
-
-export { buildCalleeResolver, buildImportsFix, getImportedLocalName, getTsFortressImports, hasForeignBinding };
-//# sourceMappingURL=import-utils.mjs.map
+
+
+
+
+
+
+
+
+
+export const buildImportsFix = (fixer, program, names) => Arr.isEmpty(names)
+    ? []
+    : [
+        fixer.insertTextBefore(program, names
+            .map((name) => `import { ${name} } from '${TS_FORTRESS_MODULE}';\n`)
+            .join('')),
+    ];
+const isTsFortressImportDef = (node) => (node.type === AST_NODE_TYPES.ImportSpecifier ||
+    node.type === AST_NODE_TYPES.ImportDefaultSpecifier ||
+    node.type === AST_NODE_TYPES.ImportNamespaceSpecifier) &&
+    node.parent.type === AST_NODE_TYPES.ImportDeclaration &&
+    node.parent.source.value === TS_FORTRESS_MODULE;
+//# sourceMappingURL=import-utils.mjs.map