@slip-stream-kit/eslint-plugin 0.17.3 → 0.18.1

package/dist/rules/feature-public-api/feature-public-api.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from 'eslint';
+export interface Options {
+    /** The alias that maps to the package's `src/`. */
+    rootAlias?: string;
+    /** Globs; the rule is skipped for matching files. */
+    ignore?: string[];
+}
+export declare const featurePublicApi: Rule.RuleModule;

package/dist/rules/feature-public-api/index.d.ts

@@ -0,0 +1 @@
+export { featurePublicApi } from './feature-public-api';

package/dist/rules/layer-imports/index.d.ts

@@ -0,0 +1 @@
+export { layerImports } from './layer-imports';

package/dist/rules/layer-imports/layer-imports.d.ts

@@ -0,0 +1,13 @@
+import type { Rule } from 'eslint';
+export interface Options {
+    /** Folders under `src/`, lowest level first; folders in one inner array share a level. */
+    layers?: string[][];
+    /** Type-only imports carry no runtime edge, so they may point at any level. */
+    allowTypeImports?: boolean;
+    /** The alias that maps to the package's `src/`. */
+    rootAlias?: string;
+    /** Globs; the rule is skipped for matching files. */
+    ignore?: string[];
+}
+export declare const DEFAULT_LAYERS: string[][];
+export declare const layerImports: Rule.RuleModule;

package/dist/rules/no-feature-self-import/index.d.ts

@@ -0,0 +1 @@
+export { noFeatureSelfImport } from './no-feature-self-import';

package/dist/rules/no-feature-self-import/no-feature-self-import.d.ts

@@ -0,0 +1,8 @@
+import type { Rule } from 'eslint';
+export interface Options {
+    /** The alias that maps to the package's `src/`. */
+    rootAlias?: string;
+    /** Globs; the rule is skipped for matching files. */
+    ignore?: string[];
+}
+export declare const noFeatureSelfImport: Rule.RuleModule;

package/dist/utils/import-target.d.ts

@@ -0,0 +1,35 @@
+import type { Rule } from 'eslint';
+export declare const DEFAULT_ROOT_ALIAS = "#root";
+/** An import-like node whose module path is a string literal, with the literal node to report on. */
+export interface ImportSource {
+    specifier: string;
+    node: Rule.Node;
+    typeOnly: boolean;
+}
+/**
+ * The module path an import-like node names, or null for a node without a static string path
+ * (`import(name)`, a template literal, a local `export { a }`). `typeof import('x')` counts and is
+ * type-only: hulyo reaches into feature internals that way, past every import-statement rule.
+ */
+export declare const readImportSource: (node: Rule.Node) => ImportSource | null;
+/** The `src` directory of the package `filename` lives in, or null when it is not under one. */
+export declare const srcDirOf: (filename: string) => string | null;
+/**
+ * Where `specifier` points, as the path segments under `srcDir` — `['features', 'user']` for
+ * `#root/features/user` or `../../features/user`. Null for a package import, another alias, or a
+ * relative path that climbs out of `src/`: those have no layer.
+ */
+export declare const resolveUnderSrc: (filename: string, srcDir: string, specifier: string, rootAlias: string) => string[] | null;
+/** Path segments of `filename`'s directory under `srcDir`. */
+export declare const fileDirsUnderSrc: (filename: string, srcDir: string) => string[];
+/** `features/<name>` or `features/<name>/index.*` — the only paths that form a feature's public API. */
+export declare const isFeaturePublicApi: (target: readonly string[]) => boolean;
+/** The feature name a src-relative path sits in (`features/<name>/…`), or null outside `features/`. */
+export declare const featureNameOf: (segments: readonly string[]) => string | null;
+/**
+ * Every node kind that names a module: static imports, re-exports, dynamic `import('x')` and the
+ * type-level `typeof import('x')`. A rule registers one handler for all of them.
+ */
+export declare const IMPORT_SELECTORS: readonly ["ImportDeclaration", "ExportNamedDeclaration", "ExportAllDeclaration", "ImportExpression", "TSImportType"];
+/** Whether the src-layout import rules apply to `filename`: not ignored, not in a backend or e2e package. */
+export declare const isLayeredFile: (filename: string, ignore: readonly string[]) => boolean;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@slip-stream-kit/eslint-plugin",
   "type": "module",
-  "version": "0.17.3",
+  "version": "0.18.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ArthurSaenz/infra-kit.git",
@@ -41,7 +41,7 @@
     "eslint": ">=9"
   },
   "devDependencies": {
-    "@slip-stream-kit/config": "0.17.3",
+    "@slip-stream-kit/config": "0.18.1",
     "@types/node": "^26.5.1",
     "@typescript-eslint/parser": "^8.70.0",
     "@wl/eslint-config": "0.1.0",

package/readme.md

@@ -664,6 +664,97 @@ an `e2e` package (by the same package-type resolution `package-structure` uses)
 The recommended preset enables it on test-file names only, with `ignore: ['**/*.e2e.test.*']` for
 e2e suites that sit in a package of another type.
 
+### `layer-imports`
+
+Allow imports only to the **same or a lower layer** of a package's `src/`. The default levels,
+lowest first (folders on one level may import each other):
+
+```
+lib, components, shared, assets, styles, data → core, entities → features → pages, routes → app, renderer, mobile
+```
+
+A file in `src/features/` may import `lib/`, `components/`, `entities/` and other features, but not
+`pages/` or `app/`. The import is reported on its path, with the order spelled out:
+
+```
+`features` cannot import `#root/app/navigation` from the higher layer `app`. Layers import only their own level or below: lib, components, shared, assets, styles, data → core, entities → features → pages, routes → app, renderer, mobile. Move the shared code down into a lower layer, or pass it in from above.
+```
+
+The target is resolved from `#root/…` (the alias for `src/`) and from relative paths; package
+imports and other aliases are never reported. Static imports, re-exports and `import('…')` are
+checked. Type-only imports (`import type`, `typeof import()`) carry no runtime edge and are allowed
+unless `allowTypeImports: false`. Files directly in `src/`, in an unlisted folder, in a `backend` / `e2e`
+package, and test files (`__tests__/`, `*.test.*`, `*.spec.*`) are skipped: a test sets up its own
+environment (global styles, providers) like an entry point and is not part of the runtime graph.
+
+Imports between features are left to `eslint-plugin-boundaries`; this rule only judges direction.
+
+```js
+{
+  rules: {
+    '@wl/layer-imports': ['error', { layers: [['lib', 'components'], ['features'], ['pages'], ['app']] }],
+  },
+}
+```
+
+#### Options
+
+| Option             | Type         | Default          | Description                                                          |
+| ------------------ | ------------ | ---------------- | -------------------------------------------------------------------- |
+| `layers`           | `string[][]` | the levels above | Folders under `src/`, lowest level first; one inner array per level. |
+| `allowTypeImports` | `boolean`    | `true`           | Whether type-only imports may point at a higher layer.               |
+| `rootAlias`        | `string`     | `'#root'`        | The alias that maps to `src/`.                                       |
+| `ignore`           | `string[]`   | `[]`             | Globs; the rule is skipped for matching files.                       |
+
+### `feature-public-api`
+
+Require code outside a feature to import it **only through its public API** — `features/<name>` or
+`features/<name>/index` — whatever form the path takes. It closes the gaps of a
+`no-restricted-imports` pattern on `**/features/*/**`: relative deep paths
+(`../../other/components/x`) and type-level `typeof import('#root/features/x/services')` are
+reported too, and so are assets and stories inside another feature.
+
+```
+`../../flights-result/components/picker-component` reaches into the internals of feature `flights-result`. Import from its public API `#root/features/flights-result` instead, exporting what you need from `features/flights-result/index.ts`.
+```
+
+Imports inside the same feature are never reported. Type-only imports are reported as well: a type
+is part of the public API or it is internal.
+
+#### Options
+
+| Option      | Type       | Default   | Description                                    |
+| ----------- | ---------- | --------- | ---------------------------------------------- |
+| `rootAlias` | `string`   | `'#root'` | The alias that maps to `src/`.                 |
+| `ignore`    | `string[]` | `[]`      | Globs; the rule is skipped for matching files. |
+
+### `no-feature-self-import`
+
+Forbid a feature from importing **itself through its own public API** (`#root/features/<own>`,
+`'..'`, `'../index'`). The feature's `index.ts` re-exports the importing file, so the import closes
+a cycle and can hand back `undefined` during module evaluation.
+
+```
+`#root/features/coupons` imports feature `coupons` through its own public API from inside it, which makes an import cycle via `index.ts`. Import the module that defines it with a relative path instead.
+```
+
+A type-only self-import closes no runtime cycle, so it gets its own message that asks for the
+relative path by convention instead:
+
+```
+`#root/features/coupons` reads types of feature `coupons` through its own public API from inside it. Import them from the module that defines them with a relative path; the public API is for code outside the feature.
+```
+
+Files in the feature's `__tests__/` and `__stories__/` are exempt: they consume the feature from
+outside, so the public API is the right entry for them.
+
+#### Options
+
+| Option      | Type       | Default   | Description                                    |
+| ----------- | ---------- | --------- | ---------------------------------------------- |
+| `rootAlias` | `string`   | `'#root'` | The alias that maps to `src/`.                 |
+| `ignore`    | `string[]` | `[]`      | Globs; the rule is skipped for matching files. |
+
 ### `e2e-file-layout`
 
 Hold an **e2e package** to its file layout: specs are `*.spec.ts` at the root of a domain folder