eslint-plugin-yenz 2.2.0-beta.2 → 2.2.2

package/.github/workflows/test.yml

@@ -9,8 +9,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      # Before setup-node cache: yarn — see https://github.com/actions/setup-node/issues/1027
+      - run: corepack enable
       - uses: actions/setup-node@v6
         with:
           node-version: 24
-      - run: yarn install --frozen-lockfile
+          cache: yarn
+      - run: yarn install --immutable
       - run: yarn test

package/.yarnrc.yml

@@ -0,0 +1 @@
+nodeLinker: node-modules

package/README.md

@@ -121,10 +121,46 @@ arr.filter((item) => item.active);
 class Foo { bar = () => {} }
 ```
 
+### `yenz/export-at-end-of-file`
+
+Disallows inline exports on function, class, type alias, and interface declarations. Prefer declaring first, then exporting all symbols in one statement at the end of the file. Auto-fixable.
+
+> **Note:** This rule is *not* enabled in the `recommended`. Enable it explicitly or use `all`.
+
+**Bad:**
+
+```typescript
+export function parseDate(input: string) {
+  return new Date(input);
+}
+
+export interface UserProfile {
+  id: string;
+}
+
+export type UserStatus = 'active' | 'inactive';
+```
+
+**Good:**
+
+```typescript
+function parseDate(input: string) {
+  return new Date(input);
+}
+
+interface UserProfile {
+  id: string;
+}
+
+type UserStatus = 'active' | 'inactive';
+
+export { parseDate, type UserProfile, type UserStatus };
+```
+
 ## Preset Configurations
 
 - `**recommended**` - Enables `type-ordering` as error and `no-loops` as warning
-- `**all**` - Enables all rules (`type-ordering`, `no-loops`, `no-named-arrow-functions`) as errors
+- `**all**` - Enables `type-ordering`, `no-loops`, and `no-named-arrow-functions` as errors
 
 # Release Procedure
 
@@ -134,14 +170,17 @@ class Foo { bar = () => {} }
 4. Add code samples in `test/` that intentionally fail your new or updated rules to confirm they are caught.
 5. Commit and push your changes, then open a PR.
 6. **Bump to a pre-release version and publish a beta:**
+
   ```bash
    yarn version --pre[major|minor|patch] --preid beta
    npm publish --tag beta                # or alpha, rc
   ```
+
    Users can test it with:
 7. After review, **merge your branch into `main`**.
 8. Open a version bump PR against `main` and merge it in.
 9. **Publish the stable release** from `main`:
+
   ```bash
    yarn version --[major|minor|patch]
    npm publish

package/index.js

@@ -31,6 +31,7 @@ plugin.configs = {
       'yenz/type-ordering': 'error',
       'yenz/no-loops': 'error',
       'yenz/no-named-arrow-functions': 'error',
+      'yenz/export-at-end-of-file': 'error',
     },
   },
 };

package/lib/rules/export-at-end-of-file.js

@@ -39,27 +39,49 @@ function isInlineExportableDeclaration(node) {
   return EXPORTABLE_DECLARATION_TYPES.has(declaration.type) && Boolean(declaration.id);
 }
 
+/**
+ * Matches `export default function foo() {}`, `export default class Foo {}`, or
+ * TypeScript `export default interface …` / `export default type …` when the
+ * declaration is named. Anonymous `export default function () {}` is skipped
+ * because there is no local binding to list in a trailing specifier export.
+ *
+ * @param {object} node - Top-level program statement node.
+ * @returns {boolean}
+ */
+function isInlineDefaultExportableDeclaration(node) {
+  if (node.type !== 'ExportDefaultDeclaration' || !node.declaration) {
+    return false;
+  }
+  const { declaration } = node;
+  if (!EXPORTABLE_DECLARATION_TYPES.has(declaration.type)) {
+    return false;
+  }
+  return Boolean(declaration.id);
+}
+
 /**
  * Extracts the exported name (and whether it's type-only) from an inline
  * export declaration so it can be appended to the consolidated export list.
  *
  * @param {object} exportNamedNode - An `ExportNamedDeclaration` node that
  *   has already been validated by {@link isInlineExportableDeclaration}.
- * @returns {{ name: string, isType: boolean }} Export item describing the
- *   declared identifier and whether it should be marked `type` in the final
- *   export statement.
+ * @returns {{ localName: string, exportedName: string, isType: boolean }}
+ *   Export item describing the declared binding, its exported name, and
+ *   whether it should be marked `type` in the final export statement.
  */
 function getExportItem(exportNamedNode) {
   const { declaration } = exportNamedNode;
+  const name = declaration.id.name;
   return {
-    name: declaration.id.name,
+    localName: name,
+    exportedName: name,
     isType: TYPE_ONLY_DECLARATION_TYPES.has(declaration.type),
   };
 }
 
 /**
- * Reads the items from an existing specifier-only export statement so they
- * can be merged with the items we are about to append.
+ * Reads named specifiers and an optional `… as default` from an existing
+ * specifier-only export so they can be merged with new items.
  *
  * Handles both forms of type-only exports:
  *   - Statement-level: `export type { Foo, Bar }` → `exportNode.exportKind === 'type'`
@@ -67,24 +89,35 @@ function getExportItem(exportNamedNode) {
  *
  * @param {object} exportNode - An `ExportNamedDeclaration` with no
  *   `declaration` and no `source` (i.e. a bare `export { … }`).
- * @returns {Array<{ name: string, isType: boolean }>} The specifier list
- *   normalized into the same shape returned by {@link getExportItem}.
+ * @returns {{
+ *   namedItems: Array<{ localName: string, exportedName: string, isType: boolean }>,
+ *   defaultLocalName: string | null
+ * }}
  */
-function getSpecifierOnlyExportItems(exportNode) {
-  const items = [];
+function parseSpecifierOnlyExport(exportNode) {
+  const namedItems = [];
+  let defaultLocalName = null;
   for (const specifier of exportNode.specifiers) {
-    // Skip `export { x as default }` (handled by ExportSpecifier with non-Identifier
-    // exported, e.g. StringLiteral) and any non-ExportSpecifier nodes a parser
-    // might produce.
     if (specifier.type !== 'ExportSpecifier' || specifier.exported.type !== 'Identifier') {
       continue;
     }
+    if (specifier.local.type !== 'Identifier') {
+      continue;
+    }
+    if (specifier.exported.name === 'default') {
+      defaultLocalName = specifier.local.name;
+      continue;
+    }
     const isType =
       specifier.exportKind === 'type' ||
       (exportNode.exportKind === 'type' && !exportNode.declaration);
-    items.push({ name: specifier.exported.name, isType });
+    namedItems.push({
+      localName: specifier.local.name,
+      exportedName: specifier.exported.name,
+      isType,
+    });
   }
-  return items;
+  return { namedItems, defaultLocalName };
 }
 
 /**
@@ -107,61 +140,87 @@ function findSpecifierOnlyExport(programNode) {
  * dropping duplicates by name (existing wins, so an existing `type` marker
  * isn't accidentally downgraded to a value export).
  *
- * @param {Array<{ name: string, isType: boolean }>} existingItems
- * @param {Array<{ name: string, isType: boolean }>} addedItems
- * @returns {Array<{ name: string, isType: boolean }>} Deduplicated, ordered
- *   list of export items.
+ * @param {Array<{ localName: string, exportedName: string, isType: boolean }>} existingItems
+ * @param {Array<{ localName: string, exportedName: string, isType: boolean }>} addedItems
+ * @returns {Array<{ localName: string, exportedName: string, isType: boolean }>}
+ *   Deduplicated, ordered list of export items (keyed by exported name).
  */
 function mergeExportItems(existingItems, addedItems) {
   const seen = new Set();
   const merged = [];
   for (const item of existingItems) {
-    if (seen.has(item.name)) continue;
-    seen.add(item.name);
+    if (seen.has(item.exportedName)) continue;
+    seen.add(item.exportedName);
     merged.push(item);
   }
   for (const item of addedItems) {
-    if (seen.has(item.name)) continue;
-    seen.add(item.name);
+    if (seen.has(item.exportedName)) continue;
+    seen.add(item.exportedName);
     merged.push(item);
   }
   return merged;
 }
 
 /**
- * Renders a list of export items as a single `export { … }` statement. When
- * every item is type-only the output uses the statement-level `export type
- * { … }` form; otherwise mixed lists use per-name `type` markers so type
- * symbols stay erasable under `verbatimModuleSyntax`/isolated modules.
+ * @param {string | null} existingDefault
+ * @param {string | null} addedDefault
+ * @returns {string | null}
+ */
+function mergeDefaultExportLocal(existingDefault, addedDefault) {
+  if (addedDefault !== null) {
+    return addedDefault;
+  }
+  return existingDefault;
+}
+
+/** @param {{ localName: string, exportedName: string }} item */
+function formatNamedSpecifierEntry(item) {
+  if (item.localName === item.exportedName) {
+    return item.localName;
+  }
+  return `${item.localName} as ${item.exportedName}`;
+}
+
+/**
+ * Renders named specifiers and an optional default as one export statement.
+ * When every named item is type-only and there is no default, uses
+ * `export type { … }`; otherwise uses `export { … }` with per-name `type`
+ * markers where needed.
  *
- * @param {Array<{ name: string, isType: boolean }>} items
+ * @param {Array<{ localName: string, exportedName: string, isType: boolean }>} namedItems
+ * @param {string | null} defaultLocalName - Local binding listed as `name as default`.
  * @returns {string} A single-line export statement (no trailing newline).
  */
-function formatMergedSpecifierExport(items) {
-  if (items.length === 0) {
+function formatMergedSpecifierExport(namedItems, defaultLocalName) {
+  const parts = namedItems.map((item) => {
+    const entry = formatNamedSpecifierEntry(item);
+    return item.isType ? `type ${entry}` : entry;
+  });
+  if (defaultLocalName !== null) {
+    parts.push(`${defaultLocalName} as default`);
+  }
+  if (parts.length === 0) {
     return 'export {}';
   }
-  if (items.every((item) => item.isType)) {
-    return `export type { ${items.map((item) => item.name).join(', ')} }`;
+  const canUseExportTypeStatement =
+    defaultLocalName === null && namedItems.length > 0 && namedItems.every((item) => item.isType);
+  if (canUseExportTypeStatement) {
+    return `export type { ${namedItems.map((item) => formatNamedSpecifierEntry(item)).join(', ')} }`;
   }
-  return `export { ${items
-    .map((item) => (item.isType ? `type ${item.name}` : item.name))
-    .join(', ')} }`;
+  return `export { ${parts.join(', ')} }`;
 }
 
 /**
- * Returns a location that covers only the exported header (for example
- * `export function foo()` through the closing `)`), not the whole declaration
- * body, so editors underline the signature instead of the entire block.
+ * Returns a location that covers only the declaration header (through `(` or
+ * `{` before the body, or through `=` for type aliases), not the whole block.
  *
- * @param {object} exportNamedNode - Inline `ExportNamedDeclaration`.
+ * @param {object} declaration - Function, class, interface, or type alias node.
+ * @param {object} reportStart - `loc.start` of the export statement.
+ * @param {object} endFallbackLoc - Full span if no tighter range applies.
  * @param {import('eslint').SourceCode} sourceCode
  * @returns {object} ESLint `SourceLocation` (`start` / `end` in line/column).
  */
-function getInlineExportReportLoc(exportNamedNode, sourceCode) {
-  const declaration = exportNamedNode.declaration;
-  const { start } = exportNamedNode.loc;
-
+function getDeclarationSignatureLoc(declaration, reportStart, endFallbackLoc, sourceCode) {
   const endsBeforeBraceBody =
     (declaration.type === 'FunctionDeclaration'
       || declaration.type === 'ClassDeclaration'
@@ -171,7 +230,7 @@ function getInlineExportReportLoc(exportNamedNode, sourceCode) {
   if (endsBeforeBraceBody) {
     const bodyOpenIndex = declaration.body.range[0];
     return {
-      start,
+      start: reportStart,
       end: sourceCode.getLocFromIndex(bodyOpenIndex),
     };
   }
@@ -183,13 +242,25 @@ function getInlineExportReportLoc(exportNamedNode, sourceCode) {
     });
     if (equalsToken) {
       return {
-        start,
+        start: reportStart,
         end: sourceCode.getLocFromIndex(equalsToken.range[0]),
       };
     }
   }
 
-  return exportNamedNode.loc;
+  return endFallbackLoc;
+}
+
+function getInlineExportReportLoc(exportNamedNode, sourceCode) {
+  const declaration = exportNamedNode.declaration;
+  const { start } = exportNamedNode.loc;
+  return getDeclarationSignatureLoc(declaration, start, exportNamedNode.loc, sourceCode);
+}
+
+function getInlineDefaultExportReportLoc(exportDefaultNode, sourceCode) {
+  const declaration = exportDefaultNode.declaration;
+  const { start } = exportDefaultNode.loc;
+  return getDeclarationSignatureLoc(declaration, start, exportDefaultNode.loc, sourceCode);
 }
 
 const exportAtEndOfFileRule = {
@@ -197,7 +268,7 @@ const exportAtEndOfFileRule = {
     type: 'suggestion',
     docs: {
       description:
-        'Disallow inline export on function, class, type, or interface declarations; use a single export list at the end of the file',
+        'Disallow inline export (including default export) on function, class, type, or interface declarations; use export specifiers at the end of the file',
       recommended: false,
     },
     fixable: 'code',
@@ -213,47 +284,63 @@ const exportAtEndOfFileRule = {
       // applies fixes in document order, and reporting the same set of edits
       // from every violation would race and produce overlapping fixes.
       'Program:exit'(programNode) {
-        const violations = programNode.body.filter(isInlineExportableDeclaration);
+        const violations = programNode.body.filter(
+          (statement) =>
+            isInlineExportableDeclaration(statement)
+            || isInlineDefaultExportableDeclaration(statement)
+        );
         if (violations.length === 0) {
           return;
         }
 
-        const addedExportItems = violations.map(getExportItem);
+        const addedExportItems = violations
+          .filter((node) => node.type === 'ExportNamedDeclaration')
+          .map(getExportItem);
+
+        let addedDefaultLocal = null;
+        for (const node of violations) {
+          if (node.type === 'ExportDefaultDeclaration' && node.declaration?.id) {
+            addedDefaultLocal = node.declaration.id.name;
+          }
+        }
+
         const lastViolation = violations[violations.length - 1];
 
         violations.forEach((node) => {
+          const reportLoc =
+            node.type === 'ExportDefaultDeclaration'
+              ? getInlineDefaultExportReportLoc(node, sourceCode)
+              : getInlineExportReportLoc(node, sourceCode);
+
           context.report({
-            loc: getInlineExportReportLoc(node, sourceCode),
+            loc: reportLoc,
             message:
               'Declare this without inline export and list it in a single export statement at the end of the file.',
             ...(node === lastViolation
               ? {
                   fix(fixer) {
-                    // Strip the leading `export` from each violation by
-                    // replacing the whole `ExportNamedDeclaration` node with
-                    // the source text of its inner declaration.
                     const edits = violations.map((exportNode) =>
                       fixer.replaceText(exportNode, sourceCode.getText(exportNode.declaration))
                     );
 
                     const existingExport = findSpecifierOnlyExport(programNode);
                     if (existingExport) {
-                      const merged = mergeExportItems(
-                        getSpecifierOnlyExportItems(existingExport),
-                        addedExportItems
-                      );
+                      const { namedItems: existingNamed, defaultLocalName: existingDefault } =
+                        parseSpecifierOnlyExport(existingExport);
+                      const mergedNamed = mergeExportItems(existingNamed, addedExportItems);
+                      const mergedDefault = mergeDefaultExportLocal(existingDefault, addedDefaultLocal);
                       edits.push(
-                        fixer.replaceText(existingExport, formatMergedSpecifierExport(merged))
+                        fixer.replaceText(
+                          existingExport,
+                          formatMergedSpecifierExport(mergedNamed, mergedDefault)
+                        )
                       );
                     } else {
-                      // No bare export to merge into - append a fresh one
-                      // after the program's last token. Ends with a newline to follow
-                      // best practices.
                       const lastToken = sourceCode.getLastToken(programNode);
                       edits.push(
                         fixer.insertTextAfter(
                           lastToken,
-                          `\n\n${formatMergedSpecifierExport(addedExportItems)}\n`
+                          `\n\n${formatMergedSpecifierExport(addedExportItems, addedDefaultLocal)}\n`
                         )
                       );
                     }

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "eslint-plugin-yenz",
-  "version": "2.2.0-beta.2",
+  "version": "2.2.2",
+  "packageManager": "yarn@4.10.2",
   "description": "Adds custom rules that Jens likes",
   "repository": "https://github.com/JensAstrup/eslint-plugin-yenz",
   "type": "module",
@@ -21,7 +22,7 @@
   "license": "ISC",
   "devDependencies": {
     "eslint": "^10.0.1",
-    "typescript": "^5.0.0",
+    "typescript": "^6.0.3",
     "typescript-eslint": "^8.0.0"
   },
   "peerDependencies": {

package/test/fixtures.ts

@@ -47,3 +47,11 @@ export class ExportClass { method() { return 1; } } // expect-error yenz/export-
 export type FixtureExportType = 1 // expect-error yenz/export-at-end-of-file // fix: type FixtureExportType = 1
 
 export interface FixtureExportIface { n: number } // expect-error yenz/export-at-end-of-file // fix: interface FixtureExportIface { n: number }
+
+export default function defaultExport() { return 1; } // expect-error yenz/export-at-end-of-file // fix: function defaultExport() { return 1; }
+
+// Should pass (export-at-end-of-file — specifier exports and non-exported decls only):
+function notExported() {}
+function someExisting() {}
+export { someExisting as someExistingPublic }
+export { foo } from './other'