eslint-plugin-ts-fortress 1.2.4 → 1.3.0

package/README.md

@@ -2,8 +2,8 @@
 
 ESLint rules that steer schema definitions toward
 [`ts-fortress`](https://www.npmjs.com/package/ts-fortress) idioms. Every rule except
-`prefer-schema-over-guard-chain` (which only reports) is auto-fixable, and every
-rewrite is **type-preserving**.
+`prefer-schema-over-guard-chain` and `no-type-only-codec` (which only report) is
+auto-fixable, and every rewrite is **type-preserving**.
 
 ## Installation
 
@@ -11,8 +11,10 @@ rewrite is **type-preserving**.
 npm install --save-dev eslint-plugin-ts-fortress
 ```
 
-Requires ESLint 9+ (flat config) and TypeScript. No rule is type-aware, so a
-configured TypeScript project is not required.
+Requires ESLint 9+ (flat config) and TypeScript. A configured TypeScript project
+is not required: only `no-type-only-codec` reads type information, and without it
+the rule checks less rather than failing (see
+[Type information](#type-information)).
 
 ## Usage (flat config)
 
@@ -73,6 +75,7 @@ export default [
 | `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. |
+| `no-type-only-codec`                       | Report a codec whose value nothing reads, only the type `TypeOf` derives from it.              |
 
 ### `prefer-canonical-length-constrained-type`
 
@@ -296,6 +299,101 @@ least interested in, while the chain of five narrows the result of a
 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.
 
+### `no-type-only-codec`
+
+A codec exists to check values at runtime. One whose value nothing reads — it is
+there only so that `t.TypeOf` can derive a type from it — is a type written the
+long way round: it costs a runtime object, keeps `ts-fortress` in the bundle of
+whatever imports it, and reads as if something validated with it.
+
+```ts
+// ❌ — every import of `User` elsewhere is `import type`
+export const User = t.record({ name: t.string() });
+
+export type User = t.TypeOf<typeof User>;
+
+// ✅
+export type User = Readonly<{ name: string }>;
+```
+
+The rule looks at a top-level `const X` paired with a top-level
+`type Y = t.TypeOf<typeof X>` — `Y` is usually `X` itself, or `X` is named
+`yTypeDef` — and reports `X` when none of these reads its value:
+
+- **its own file**: any reference outside a type. `typeof X` in another type
+  does not count; `t.array(X)` in another codec does.
+- **the other files of the TypeScript project**: an import that is not
+  `import type` / `import { type X }`, whatever the importer then does with it;
+  a namespace import read as `ns.X` or `ns['X']` outside a type, or used whole
+  (`f(ns)`, `ns[key]`); a dynamic `import()`. Re-exports are followed, so a
+  barrel is transparent.
+- **an entry point** — a file the package publishes (see
+  [Entry points](#entry-points)) — that re-exports it as a value, directly or
+  through any chain of `export { … } from` / `export * from`.
+
+The rule reports; there is no fix, since writing the type out is not
+mechanical.
+
+#### Type information
+
+Whether another file reads an exported codec is a question about the whole
+TypeScript project, so the rule answers it from the program a file is linted
+with. Turn type information on for it to check exported codecs at all:
+
+```ts
+// eslint.config.mts
+import { eslintPluginTsFortress } from 'eslint-plugin-ts-fortress';
+
+export default [
+    eslintPluginTsFortress.configs.recommended,
+    {
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigRootDir: import.meta.dirname,
+            },
+        },
+    },
+];
+```
+
+Without it, a codec that is not exported is still checked — that needs nothing
+but its own file — and an exported one is left alone.
+
+The rule sees the files of that program and nothing else. An importer counts
+only if the `tsconfig.json` linting the codec's file includes it, so tests under
+a separate project import nothing as far as the rule can tell, and another
+package that imports the codec reaches it through an entry point.
+
+#### Entry points
+
+A codec the package publishes is public API, whoever uses it. The entry points
+are read from the `package.json` nearest to the file — `exports`, every subpath
+and condition of it, and the legacy `main`, `module`, `types` and `typings`
+fields — and traced back to source: a target that is a file of the project is
+taken as it is, and an output such as `./dist/index.mjs` becomes the source it
+was built from, `src/index.mts` (the project's `outDir` and `rootDir` are used
+when set; otherwise a leading `dist`, `lib`, `build`, `out`, `esm` or `cjs`
+directory becomes `src`). The conditions of one subpath describe one module, so
+a subpath counts as traced when any of its targets is, and a `types` file a
+build writes on its own does not need a source. A package that publishes nothing
+— an application — has no entry points.
+
+When some subpath cannot be traced back to a file of the project, what the
+package publishes is not known, and the rule leaves its exported codecs alone
+rather than report public API. Name the entry points yourself for such a layout:
+
+```ts
+'ts-fortress/no-type-only-codec': [
+  'error',
+  { entryPoints: [path.resolve(import.meta.dirname, 'src/public-api.mts')] },
+],
+```
+
+- `entryPoints` (default: read from `package.json`) — the files whose exports
+  are public API, replacing what `package.json` says. Relative paths resolve
+  against the directory ESLint runs in, so pass absolute ones, as above.
+
 ## License
 
 [Apache-2.0](https://github.com/noshiro-pf/mono/blob/main/libs/eslint-plugin-ts-fortress/LICENSE)

package/dist/plugin.d.mts

@@ -1,9 +1,12 @@
-import { type ESLintPlugin } from './types.mjs';
+import type { ESLintPlugin } from './types.mjs';
 export declare const eslintPluginTsFortress: {
     readonly meta: {
         readonly name: 'eslint-plugin-ts-fortress';
     };
     readonly rules: {
+        readonly 'no-type-only-codec': import("@typescript-eslint/utils/ts-eslint").RuleModule<"typeOnlyCodec", readonly [(Readonly<{
+            entryPoints?: readonly string[];
+        }> | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         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;
@@ -21,6 +24,7 @@ export declare const eslintPluginTsFortress: {
                 readonly 'ts-fortress': ESLintPlugin;
             };
             readonly rules: {
+                readonly 'ts-fortress/no-type-only-codec': 'error';
                 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;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"}
+{"version":3,"file":"plugin.d.mts","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAoB,YAAY,EAAE,MAAM,aAAa,CAAC;AAmClE,eAAO,MAAM,sBAAsB;;iBAE/B,IAAI,EAAE,2BAA2B;;;;;;;;;;;;;;;;QAIjC,oDAAoD;iBACpD,WAAW;2BAtBP,yBAAyB;;yBAQzB,aAAa,EAAI,YAAY;;;2DAlBD,OAAO;iFACe,OAAO;gEACxB,OAAO;uEACA,OAAO;;;;CA+BtB,CAAC"}

package/dist/plugin.mjs

@@ -5,7 +5,9 @@ import { tsFortressRules } from './rules/index.mjs';
 
 
 
+
 const recommendedRules = {
+    'ts-fortress/no-type-only-codec': 'error',
     'ts-fortress/prefer-canonical-length-constrained-type': 'error',
     'ts-fortress/prefer-namespace-import': 'error',
     'ts-fortress/prefer-schema-over-guard-chain': 'error',

package/dist/plugin.mjs.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"plugin.mjs","sourceRoot":"","sources":["../src/plugin.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;;;;GAMG;AACH,MAAM,gBAAgB,GAAG;IACvB,gCAAgC,EAAE,OAAO;IACzC,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,7 +1,7 @@
-import { type TSESLint } from '@typescript-eslint/utils';
-import { type Linter } from 'eslint';
-import { type TypeEq } from 'ts-type-forge';
-import { type tsFortressRules } from './rules/index.mjs';
+import type { TSESLint } from '@typescript-eslint/utils';
+import type { Linter } from 'eslint';
+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
@@ -9,6 +9,43 @@ type SpreadOptionsIfIsArray<T extends readonly [Linter.StringSeverity, unknown]>
  * 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 Report a ts-fortress codec `X` paired with `type Y = t.TypeOf<typeof X>` whose value nothing reads, so that `Y` is declared as a plain type instead.
+ *
+ *  ```md
+ *  | key        | value      |
+ *  | :--------- | :--------- |
+ *  | type       | suggestion |
+ *  | deprecated | false      |
+ *  | fixable    | false      |
+ *  ```
+ */
+declare namespace NoTypeOnlyCodec {
+    /**
+     * ### schema
+     *
+     * ```json
+     * [
+     *   {
+     *     "type": "object",
+     *     "properties": {
+     *       "entryPoints": {
+     *         "type": "array",
+     *         "items": {
+     *           "type": "string"
+     *         },
+     *         "uniqueItems": true,
+     *         "description": "Files whose exports are public API. A codec they export, directly or through re-exports, is never reported. Replaces the entry points read from the nearest package.json, for a layout they cannot be traced back to source from. Relative paths are resolved against the working directory ESLint runs in; pass absolute paths to make the config independent of it."
+     *       }
+     *     },
+     *     "additionalProperties": false
+     *   }
+     * ]
+     * ```
+     */
+    type Options = NonNullable<RuleOptionsOf<'no-type-only-codec'>[0]>;
+    type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
+}
 /**
  * @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.
  *
@@ -99,11 +136,13 @@ declare namespace PreferSchemaOverGuardChain {
     type RuleEntry = 'off' | Linter.Severity | SpreadOptionsIfIsArray<readonly [Linter.StringSeverity, Options]>;
 }
 export type EslintTsFortressRules = Readonly<{
+    'ts-fortress/no-type-only-codec': NoTypeOnlyCodec.RuleEntry;
     '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/no-type-only-codec': NoTypeOnlyCodec.Options;
     'ts-fortress/prefer-namespace-import': PreferNamespaceImport.Options;
     'ts-fortress/prefer-schema-over-guard-chain': PreferSchemaOverGuardChain.Options;
 }>;

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,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"}
+{"version":3,"file":"rule-types.d.mts","sourceRoot":"","sources":["../src/rule-types.mts"],"names":[],"mappings":"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"}

package/dist/rules/ast-utils.d.mts

@@ -0,0 +1,15 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+/**
+ * `node` with every `as`, `satisfies`, `!` and `<T>` around it taken off: the
+ * expression whose value it is. Judge syntax on what this returns, so that a
+ * wrapper does not hide a pattern (`isString((x as R).a)`), and keep the
+ * original node for fix text. See `docs/writing-lint-rules.md` at the
+ * repository root.
+ *
+ * A copy of the helper in `eslint-config-typed`, which this package, published
+ * on its own, cannot import.
+ */
+export declare const skipTypeWrappers: (node: TSESTree.Node) => TSESTree.Node;
+export declare const isTypeWrapper: (node: TSESTree.Node) => node is TypeWrapper;
+export type TypeWrapper = TSESTree.TSAsExpression | TSESTree.TSNonNullExpression | TSESTree.TSSatisfiesExpression | TSESTree.TSTypeAssertion;
+//# sourceMappingURL=ast-utils.d.mts.map

package/dist/rules/ast-utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.d.mts","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzE;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,SAErB,QAAQ,CAAC,IAAI,KAClB,QAAQ,CAAC,IACoD,CAAC;AAEjE,eAAO,MAAM,aAAa,SAElB,QAAQ,CAAC,IAAI,KAClB,IAAI,IAAI,WAA2C,CAAC;AAEvD,MAAM,MAAM,WAAW,GACnB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,mBAAmB,GAC5B,QAAQ,CAAC,qBAAqB,GAC9B,QAAQ,CAAC,eAAe,CAAC"}

package/dist/rules/ast-utils.mjs

@@ -0,0 +1,24 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+
+
+
+
+
+
+
+
+
+
+export const skipTypeWrappers = (
+
+node) => isTypeWrapper(node) ? skipTypeWrappers(node.expression) : node;
+export const isTypeWrapper = (
+
+node) => TYPE_WRAPPERS.has(node.type);
+const TYPE_WRAPPERS = new Set([
+    AST_NODE_TYPES.TSAsExpression,
+    AST_NODE_TYPES.TSNonNullExpression,
+    AST_NODE_TYPES.TSSatisfiesExpression,
+    AST_NODE_TYPES.TSTypeAssertion,
+]);
+//# sourceMappingURL=ast-utils.mjs.map

package/dist/rules/ast-utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.mjs","sourceRoot":"","sources":["../../src/rules/ast-utils.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAiB,MAAM,0BAA0B,CAAC;AAEzE;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;AAC9B,8EAA8E;AAC9E,IAAmB,EACJ,EAAE,CACjB,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AAEjE,MAAM,CAAC,MAAM,aAAa,GAAG;AAC3B,8EAA8E;AAC9E,IAAmB,EACE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAQvD,MAAM,aAAa,GAAgC,IAAI,GAAG,CAAC;IACzD,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,qBAAqB;IACpC,cAAc,CAAC,eAAe;CAC/B,CAAC,CAAC"}

package/dist/rules/export-usage.d.mts

@@ -0,0 +1,19 @@
+import * as ts from 'typescript';
+/**
+ * Whether the value `fileName` exports as `exportName` may be read at runtime
+ * by a file of `program`, or is public API because one of `entryPoints`
+ * re-exports it.
+ *
+ * Answered from the import and export declarations of every file in the
+ * program, nothing more, and it errs towards "used" wherever they do not
+ * decide it: a non-type import counts as a value use whatever the importer does
+ * with it, and a namespace or a module that leaves the file whole (a dynamic
+ * `import()`, `export { ns }`, `f(ns)`) uses every export. A type-only import or
+ * re-export is never a use. A re-export is followed to what imports the
+ * re-exporting file, so a barrel is transparent.
+ *
+ * Files outside `program` are not seen at all, so an importer only counts when
+ * the TypeScript project that lints `fileName` includes it.
+ */
+export declare const isExportedValueUsed: (program: ts.Program, fileName: string, exportName: string, entryPoints: ReadonlySet<string>) => boolean;
+//# sourceMappingURL=export-usage.d.mts.map

package/dist/rules/export-usage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-usage.d.mts","sourceRoot":"","sources":["../../src/rules/export-usage.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,YACrB,EAAE,CAAC,OAAO,YACT,MAAM,cACJ,MAAM,eACL,WAAW,CAAC,MAAM,CAAC,KAC/B,OACyE,CAAC"}

package/dist/rules/export-usage.mjs

@@ -0,0 +1,252 @@
+import * as ts from 'typescript';
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+export const isExportedValueUsed = (program, fileName, exportName, entryPoints) => isUsed(importEdges(program), entryPoints, fileName, exportName, new Set());
+
+
+
+
+
+const importEdgesCache = new WeakMap();
+
+
+
+
+const namespaceMembersCache = new WeakMap();
+
+const DYNAMIC_IMPORT_PATTERN = /\b(?:import|require)\s*\(/u;
+
+const isUsed = (edges, entryPoints, fileName, exportName, mut_visited) => {
+    if (entryPoints.has(fileName)) {
+        return true;
+    }
+    const key = `${fileName}\0${exportName}`;
+
+    if (mut_visited.has(key)) {
+        return false;
+    }
+    mut_visited.add(key);
+    const follow = (importer, name) => isUsed(edges, entryPoints, importer, name, mut_visited);
+    return (edges.get(fileName) ?? []).some((edge) => {
+        switch (edge.kind) {
+            case 'everything':
+                return true;
+            case 'named':
+                return edge.name === exportName;
+            case 'namespace': {
+                const members = namespaceMembers(edge);
+                return members === 'all' || members.has(exportName);
+            }
+            case 're-export':
+                return edge.name === exportName && follow(edge.importer, edge.as);
+            case 're-export-all':
+
+                return exportName !== 'default' && follow(edge.importer, exportName);
+            case 're-export-namespace':
+                return follow(edge.importer, edge.as);
+        }
+    });
+};
+
+const importEdges = (program) => {
+    const cached = importEdgesCache.get(program);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const checker = program.getTypeChecker();
+    const mut_edges = new Map();
+    const add = (moduleSpecifier, ...edges) => {
+        const target = resolveModule(checker, moduleSpecifier);
+        if (target === undefined) {
+            return;
+        }
+        const mut_existing = mut_edges.get(target);
+        if (mut_existing === undefined) {
+            mut_edges.set(target, Array.from(edges));
+        }
+        else {
+            mut_existing.push(...edges);
+        }
+    };
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile ||
+            program.isSourceFileFromExternalLibrary(sourceFile) ||
+            program.isSourceFileDefaultLibrary(sourceFile)) {
+            continue;
+        }
+        for (const statement of sourceFile.statements) {
+            collectStatementEdges(sourceFile, statement, add);
+        }
+
+
+        if (DYNAMIC_IMPORT_PATTERN.test(sourceFile.text)) {
+            collectDynamicImportEdges(sourceFile, add);
+        }
+    }
+    importEdgesCache.set(program, mut_edges);
+    return mut_edges;
+};
+const collectStatementEdges = (sourceFile, statement, add) => {
+    if (ts.isImportDeclaration(statement)) {
+        const clause = statement.importClause;
+
+
+        if (clause === undefined || ts.isTypeOnlyImportDeclaration(clause)) {
+            return;
+        }
+        const bindings = clause.namedBindings;
+        add(statement.moduleSpecifier, ...(clause.name === undefined
+            ? []
+            : [{ kind: 'named', name: 'default' }]), ...(bindings === undefined
+            ? []
+            : ts.isNamespaceImport(bindings)
+                ? [
+                    {
+                        kind: 'namespace',
+                        importer: sourceFile,
+                        localName: bindings.name.text,
+                    },
+                ]
+                : bindings.elements
+                    .filter((element) => !element.isTypeOnly)
+                    .map((element) => ({
+                    kind: 'named',
+                    name: (element.propertyName ?? element.name).text,
+                }))));
+        return;
+    }
+    if (ts.isExportDeclaration(statement)) {
+        if (statement.moduleSpecifier === undefined || statement.isTypeOnly) {
+            return;
+        }
+        const exportClause = statement.exportClause;
+        const importer = sourceFile.fileName;
+        add(statement.moduleSpecifier, ...(exportClause === undefined
+            ? [{ kind: 're-export-all', importer }]
+            : ts.isNamespaceExport(exportClause)
+                ? [
+                    {
+                        kind: 're-export-namespace',
+                        importer,
+                        as: exportClause.name.text,
+                    },
+                ]
+                : exportClause.elements
+                    .filter((element) => !element.isTypeOnly)
+                    .map((element) => ({
+                    kind: 're-export',
+                    importer,
+                    name: (element.propertyName ?? element.name).text,
+                    as: element.name.text,
+                }))));
+        return;
+    }
+    if (ts.isImportEqualsDeclaration(statement) &&
+        !statement.isTypeOnly &&
+        ts.isExternalModuleReference(statement.moduleReference)) {
+        add(statement.moduleReference.expression, { kind: 'everything' });
+    }
+};
+
+
+
+
+
+const collectDynamicImportEdges = (sourceFile, add) => {
+    const visit = (node) => {
+        if (ts.isCallExpression(node) &&
+            (node.expression.kind === ts.SyntaxKind.ImportKeyword ||
+                (ts.isIdentifier(node.expression) &&
+                    node.expression.text === 'require'))) {
+            const [argument] = node.arguments;
+            if (argument !== undefined && ts.isStringLiteralLike(argument)) {
+                add(argument, { kind: 'everything' });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
+
+
+
+
+
+const resolveModule = (checker, moduleSpecifier) => checker
+    .getSymbolAtLocation(moduleSpecifier)
+    ?.declarations?.find(ts.isSourceFile)?.fileName;
+const namespaceMembers = (edge) => {
+    const cached = namespaceMembersCache.get(edge);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = collectNamespaceMembers(edge.importer, edge.localName);
+    namespaceMembersCache.set(edge, result);
+    return result;
+};
+
+
+
+
+
+
+
+const collectNamespaceMembers = (sourceFile, localName) => {
+    const mut_names = new Set();
+    const isNamespace = (node) => ts.isIdentifier(node) && node.text === localName;
+
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node) ||
+
+
+
+            (ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node))) {
+            return undefined;
+        }
+        if (ts.isPropertyAccessExpression(node) && isNamespace(node.expression)) {
+            mut_names.add(node.name.text);
+            return undefined;
+        }
+        if (ts.isElementAccessExpression(node) && isNamespace(node.expression)) {
+            if (!ts.isStringLiteralLike(node.argumentExpression)) {
+                return true;
+            }
+            mut_names.add(node.argumentExpression.text);
+            return undefined;
+        }
+        return ((isNamespace(node) && !isPropertyName(node)) ||
+            ts.forEachChild(node, visit));
+    };
+    return visit(sourceFile) === true ? 'all' : mut_names;
+};
+
+
+
+
+const isPropertyName = (node) => {
+    const parent = node.parent;
+    return (((ts.isPropertyAccessExpression(parent) ||
+        ts.isPropertyAssignment(parent) ||
+        ts.isPropertyDeclaration(parent) ||
+        ts.isMethodDeclaration(parent) ||
+        ts.isGetAccessorDeclaration(parent) ||
+        ts.isSetAccessorDeclaration(parent) ||
+        ts.isEnumMember(parent)) &&
+        parent.name === node) ||
+        (ts.isBindingElement(parent) && parent.propertyName === node));
+};
+//# sourceMappingURL=export-usage.mjs.map

package/dist/rules/export-usage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-usage.mjs","sourceRoot":"","sources":["../../src/rules/export-usage.mts"],"names":[],"mappings":"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"}

package/dist/rules/no-type-only-codec.d.mts

@@ -0,0 +1,25 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+type Options = readonly [
+    Readonly<{
+        entryPoints?: readonly string[];
+    }>?
+];
+type MessageIds = 'typeOnlyCodec';
+/**
+ * A codec exists to check values at runtime. One declared next to
+ * `type Y = t.TypeOf<typeof X>` and never read as a value is a type written the
+ * long way round: it costs a runtime object and a bundle import, and it reads
+ * as if something validated with it. This rule reports such a codec, so that
+ * `Y` becomes a plain type alias.
+ *
+ * "Never read as a value" means: no value reference in its own file outside
+ * `typeof`, every import of it elsewhere `import type`, and no entry point
+ * re-exporting it. The entry points are what the nearest `package.json`
+ * publishes, traced back to source, unless the `entryPoints` option names them.
+ * The cross-file part reads the importers from the TypeScript program; without
+ * type information, or when the published entry points cannot all be traced
+ * back to source, an exported codec is left alone.
+ */
+export declare const noTypeOnlyCodec: TSESLint.RuleModule<MessageIds, Options>;
+export {};
+//# sourceMappingURL=no-type-only-codec.d.mts.map

package/dist/rules/no-type-only-codec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-type-only-codec.d.mts","sourceRoot":"","sources":["../../src/rules/no-type-only-codec.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAQlC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KACjC,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,eAAe,CAAC;AAKlC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA2F3D,CAAC"}