@jterrazz/typescript 10.1.5 → 10.1.6

package/bin/typescript.sh

@@ -17,14 +17,17 @@ else
     PROJECT_ROOT=$(pwd)
 fi
 
-# Get the real directory where this script lives (resolve symlinks)
+# The PHYSICAL directory this script lives in, symlinks resolved on every hop.
+# `cd -P` matters: under pnpm the package sits behind a symlinked prefix, and
+# a shim found from the logical path execs a relative target that lands
+# beside the wrong parent.
 SCRIPT_PATH="$0"
 while [ -L "$SCRIPT_PATH" ]; do
-    LINK_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+    LINK_DIR="$(cd -P "$(dirname "$SCRIPT_PATH")" && pwd)"
     SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
     [[ $SCRIPT_PATH != /* ]] && SCRIPT_PATH="$LINK_DIR/$SCRIPT_PATH"
 done
-SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+SCRIPT_DIR="$(cd -P "$(dirname "$SCRIPT_PATH")" && pwd)"
 PACKAGE_ROOT="$SCRIPT_DIR/.."
 
 # Find binaries - check package's node_modules first, then project's (handles npm hoisting)

package/lib/check-names.js

@@ -63,6 +63,13 @@ const SHORTCUTS = new Set([
  */
 const SWEPT = new Set(['apps', 'bin', 'lib', 'packages', 'specs', 'src', 'tests']);
 
+/**
+ * A Next.js route segment is a URL: what a directory below `app/` is called is
+ * the address the product serves, not a name the tree chose. The router root
+ * itself is judged like any directory; what it contains is not.
+ */
+const ROUTER_ROOT = 'app';
+
 /** A `_` opens a row — a fixture, a golden, a template — and a row is not a subject. */
 const isOfTheRow = (name) => name.startsWith('_');
 
@@ -81,7 +88,8 @@ const stemOf = (name) => name.split('.')[0] ?? '';
 
 /**
  * Every name a set of paths puts on the tree, each mapped to the path that
- * carries it: every directory below a swept root, and every file's stem.
+ * carries it: every directory below a swept root that is not a route, and
+ * every file's stem.
  */
 function namesOf(files) {
     const named = new Map();
@@ -92,8 +100,11 @@ function namesOf(files) {
             continue;
         }
 
-        /* From the second segment on: the root's own name is not the project's. */
-        for (let index = 1; index < segments.length - 1; index += 1) {
+        /* From the second segment on: the root's own name is not the project's,
+         * and below a router root a directory is a route. */
+        const routerRoot = segments.indexOf(ROUTER_ROOT, 1);
+        const lastJudged = routerRoot === -1 ? segments.length - 1 : routerRoot + 1;
+        for (let index = 1; index < Math.min(lastJudged, segments.length - 1); index += 1) {
             const path = segments.slice(0, index + 1).join('/');
             named.set(path, segments[index]);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/typescript",
-    "version": "10.1.5",
+    "version": "10.1.6",
     "license": "MIT",
     "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
     "repository": {

package/rules/architecture/layers.js

@@ -22,9 +22,25 @@ import { fragment, on, scoped } from '../_contract.js';
 
 /**
  * Build a fragment from a layer map. Each layer is
- * `{ name, files, deny, allow?, message }`: `files` are the globs that BELONG
- * to the layer, `deny` the specifier globs it may not import, `allow` the
- * exceptions carved out of them.
+ * `{ name, files, deny, allow?, allowTypeImports?, message }`: `files` are the
+ * globs that BELONG to the layer, `deny` the specifier globs it may not
+ * import, `allow` the exceptions carved out of them, and `allowTypeImports`
+ * lets a type-only import cross — a type is a contract, not a dependency at
+ * runtime.
+ */
+/**
+ * @typedef {object} Layer One row of a layer map.
+ * @property {string} name What the layer is called in a refusal.
+ * @property {readonly string[]} files The globs that belong to the layer.
+ * @property {readonly string[]} deny The specifier globs it may not import.
+ * @property {readonly string[]} [allow] Exceptions carved out of `deny`.
+ * @property {boolean} [allowTypeImports] Whether a type-only import may cross.
+ * @property {string} message What a refusal says.
+ */
+
+/**
+ * @param {{ id?: string, map: readonly Layer[] }} definition The map, and the id the fragment answers to.
+ * @returns {Omit<ReturnType<typeof fragment>, 'overrides'> & { overrides: readonly import('../_contract.js').Scoped[] }} The fragment, one override per layer.
  */
 export function layers({ id = 'layers', map }) {
     assertDisjoint(id, map);
@@ -44,6 +60,9 @@ export function layers({ id = 'layers', map }) {
                                         ...(layer.allow ?? []).map((glob) => `!${glob}`),
                                     ],
                                     message: layer.message,
+                                    ...(layer.allowTypeImports === true
+                                        ? { allowTypeImports: true }
+                                        : {}),
                                 },
                             ],
                         },

package/rules/architecture/layers.test.ts

@@ -0,0 +1,48 @@
+import { expect, test } from 'vitest';
+
+import { layers } from './layers.js';
+
+const LAYER = {
+    deny: ['**/adapters/**'],
+    files: ['src/ports/**/*.ts'],
+    message: 'a port names no adapter',
+    name: 'ports',
+};
+
+test('a layer forbids the specifiers it denies and nothing else about its type imports', () => {
+    // Given - a layer that says nothing about type imports
+    // When - the map is compiled
+    const [override] = layers({ map: [LAYER] }).overrides;
+
+    // Then - the pattern carries the deny glob and no type-import exemption
+    expect(override?.decisions['no-restricted-imports']?.options).toStrictEqual([
+        { patterns: [{ group: ['**/adapters/**'], message: 'a port names no adapter' }] },
+    ]);
+});
+
+test('a layer that allows type imports lets a contract cross without its runtime', () => {
+    // Given - the same layer with type imports allowed
+    // When - the map is compiled
+    const [override] = layers({ map: [{ ...LAYER, allowTypeImports: true }] }).overrides;
+
+    // Then - the pattern says so to oxlint
+    expect(override?.decisions['no-restricted-imports']?.options).toStrictEqual([
+        {
+            patterns: [
+                {
+                    allowTypeImports: true,
+                    group: ['**/adapters/**'],
+                    message: 'a port names no adapter',
+                },
+            ],
+        },
+    ]);
+});
+
+test('two layers claiming one files glob are refused before oxlint erases one of them', () => {
+    // Given - two layers on the same glob
+    const map = [LAYER, { ...LAYER, name: 'twin' }];
+
+    // Then - the map is refused by name
+    expect(() => layers({ map })).toThrow('belongs to both "ports" and "twin"');
+});