@regardio/dev 1.10.3 → 1.11.0

package/README.md

@@ -27,7 +27,7 @@ The goal is code that's correct, consistent, and a pleasure to work with.
 | **Testing** | Vitest, Playwright, Testing Library |
 | **Build** | TypeScript, tsx, Vite |
 | **Workflow** | Husky, Changesets |
-| **CLI utilities** | exec-clean, exec-p, exec-s, exec-ts, flow-release, lint-biome, lint-md |
+| **CLI utilities** | exec-clean, exec-p, exec-s, exec-ts, flow-release, lint-biome, lint-md, lint-package |
 
 ## Quick Start
 

package/dist/bin/flow-release.js

@@ -30,6 +30,17 @@ if (!packageName) {
     process.exit(1);
 }
 console.log(`Releasing ${packageName} with ${bumpType} bump...`);
+console.log('Running quality checks...');
+try {
+    run('pnpm build');
+    run('pnpm typecheck');
+    run('pnpm report');
+}
+catch {
+    console.error('Quality checks failed. Fix issues before releasing.');
+    process.exit(1);
+}
+console.log('✅ Quality checks passed');
 try {
     const status = runQuiet('git status --porcelain');
     if (status) {

package/dist/bin/lint-package.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=lint-package.d.ts.map

package/dist/bin/lint-package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-package.d.ts","sourceRoot":"","sources":["../../src/bin/lint-package.ts"],"names":[],"mappings":""}

package/dist/bin/lint-package.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const devRoot = resolve(__dirname, '../..');
+const sortPkgBin = join(devRoot, 'node_modules/.bin/sort-package-json');
+const sortPkgBinAlt = join(devRoot, 'node_modules/sort-package-json/cli.js');
+let bin = '';
+if (existsSync(sortPkgBin)) {
+    bin = sortPkgBin;
+}
+else if (existsSync(sortPkgBinAlt)) {
+    bin = `node ${sortPkgBinAlt}`;
+}
+else {
+    bin = 'npx sort-package-json';
+}
+const args = process.argv.slice(2);
+const files = args.length > 0 ? args : ['package.json'];
+try {
+    execSync(`${bin} ${files.join(' ')}`, { stdio: 'inherit' });
+}
+catch {
+    process.exit(1);
+}
+function fixExportsOrder(filePath) {
+    const fullPath = resolve(process.cwd(), filePath);
+    if (!existsSync(fullPath))
+        return;
+    const content = readFileSync(fullPath, 'utf-8');
+    const pkg = JSON.parse(content);
+    if (!pkg.exports || typeof pkg.exports !== 'object')
+        return;
+    let modified = false;
+    function reorderConditions(obj) {
+        if (typeof obj !== 'object' || obj === null)
+            return obj;
+        if ('types' in obj && 'default' in obj) {
+            const keys = Object.keys(obj);
+            const typesIndex = keys.indexOf('types');
+            const defaultIndex = keys.indexOf('default');
+            if (defaultIndex < typesIndex) {
+                modified = true;
+                const reordered = {};
+                reordered.types = obj.types;
+                for (const key of keys) {
+                    if (key !== 'types') {
+                        reordered[key] = obj[key];
+                    }
+                }
+                return reordered;
+            }
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                result[key] = reorderConditions(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    pkg.exports = reorderConditions(pkg.exports);
+    if (modified) {
+        writeFileSync(fullPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    }
+}
+for (const file of files) {
+    fixExportsOrder(file);
+}

package/dist/bin/lint-package.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lint-package.test.d.ts.map

package/dist/bin/lint-package.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-package.test.d.ts","sourceRoot":"","sources":["../../src/bin/lint-package.test.ts"],"names":[],"mappings":""}

package/dist/bin/lint-package.test.js

@@ -0,0 +1,111 @@
+import { describe, expect, it } from 'vitest';
+function reorderConditions(obj) {
+    function processObject(o) {
+        if (typeof o !== 'object' || o === null)
+            return o;
+        const processed = {};
+        for (const [key, value] of Object.entries(o)) {
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                processed[key] = processObject(value);
+            }
+            else {
+                processed[key] = value;
+            }
+        }
+        if ('types' in processed && 'default' in processed) {
+            const keys = Object.keys(processed);
+            const typesIndex = keys.indexOf('types');
+            const defaultIndex = keys.indexOf('default');
+            if (defaultIndex < typesIndex) {
+                const reordered = {};
+                reordered.types = processed.types;
+                for (const key of keys) {
+                    if (key !== 'types') {
+                        reordered[key] = processed[key];
+                    }
+                }
+                return reordered;
+            }
+        }
+        return processed;
+    }
+    return processObject(obj);
+}
+describe('lint-package', () => {
+    describe('reorderConditions', () => {
+        it('should reorder types before default when default comes first', () => {
+            const input = {
+                './foo': {
+                    default: './dist/foo.js',
+                    types: './dist/foo.d.ts',
+                },
+            };
+            const result = reorderConditions(input);
+            expect(Object.keys(result['./foo'])).toEqual(['types', 'default']);
+        });
+        it('should not modify when types already comes before default', () => {
+            const input = {
+                './foo': {
+                    default: './dist/foo.js',
+                    types: './dist/foo.d.ts',
+                },
+            };
+            const result = reorderConditions(input);
+            expect(Object.keys(result['./foo'])).toEqual(['types', 'default']);
+        });
+        it('should handle multiple exports with mixed order', () => {
+            const input = {
+                './a': {
+                    default: './dist/a.js',
+                    types: './dist/a.d.ts',
+                },
+                './b': {
+                    default: './dist/b.js',
+                    types: './dist/b.d.ts',
+                },
+            };
+            const result = reorderConditions(input);
+            expect(Object.keys(result['./a'])[0]).toBe('types');
+            expect(Object.keys(result['./b'])[0]).toBe('types');
+        });
+        it('should preserve other keys after types', () => {
+            const input = {
+                './foo': {
+                    default: './dist/foo.js',
+                    import: './dist/foo.mjs',
+                    require: './dist/foo.cjs',
+                    types: './dist/foo.d.ts',
+                },
+            };
+            const result = reorderConditions(input);
+            const keys = Object.keys(result['./foo']);
+            expect(keys[0]).toBe('types');
+            expect(keys.slice(1)).toEqual(['default', 'import', 'require']);
+        });
+        it('should handle exports without types or default', () => {
+            const input = {
+                './styles.css': './dist/styles.css',
+            };
+            const result = reorderConditions(input);
+            expect(result).toEqual(input);
+        });
+        it('should handle deeply nested condition objects', () => {
+            const input = {
+                './foo': {
+                    browser: {
+                        default: './dist/foo.browser.js',
+                        types: './dist/foo.browser.d.ts',
+                    },
+                    node: {
+                        default: './dist/foo.node.js',
+                        types: './dist/foo.node.d.ts',
+                    },
+                },
+            };
+            const result = reorderConditions(input);
+            const foo = result['./foo'];
+            expect(Object.keys(foo.node)[0]).toBe('types');
+            expect(Object.keys(foo.browser)[0]).toBe('types');
+        });
+    });
+});

package/dist/bin/post-build-exports.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=post-build-exports.test.d.ts.map

package/dist/bin/post-build-exports.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-build-exports.test.d.ts","sourceRoot":"","sources":["../../src/bin/post-build-exports.test.ts"],"names":[],"mappings":""}

package/dist/bin/post-build-exports.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+function parseArgs(args) {
+    const result = {
+        dist: 'dist',
+        prefix: './',
+        preserve: [],
+        strip: '',
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const next = args[i + 1];
+        if (arg === '--dist' && next) {
+            result.dist = next;
+            i++;
+        }
+        else if (arg === '--preserve' && next) {
+            result.preserve = next.split(',').map((p) => p.trim());
+            i++;
+        }
+        else if (arg === '--prefix' && next) {
+            result.prefix = next;
+            i++;
+        }
+        else if (arg === '--strip' && next) {
+            result.strip = next;
+            i++;
+        }
+    }
+    return result;
+}
+function generateExportName(jsPath, strip) {
+    let exportPath = jsPath.replace(/\.js$/, '');
+    if (strip && exportPath.startsWith(strip)) {
+        exportPath = exportPath.slice(strip.length);
+        if (exportPath.startsWith('/')) {
+            exportPath = exportPath.slice(1);
+        }
+    }
+    if (exportPath.endsWith('/index')) {
+        exportPath = exportPath.slice(0, -6);
+    }
+    return `./${exportPath}`;
+}
+describe('post-build-exports', () => {
+    describe('parseArgs', () => {
+        it('should return defaults when no args provided', () => {
+            const result = parseArgs([]);
+            expect(result).toEqual({
+                dist: 'dist',
+                prefix: './',
+                preserve: [],
+                strip: '',
+            });
+        });
+        it('should parse --dist option', () => {
+            const result = parseArgs(['--dist', 'build']);
+            expect(result.dist).toBe('build');
+        });
+        it('should parse --preserve option with single value', () => {
+            const result = parseArgs(['--preserve', './tailwind.css']);
+            expect(result.preserve).toEqual(['./tailwind.css']);
+        });
+        it('should parse --preserve option with multiple comma-separated values', () => {
+            const result = parseArgs(['--preserve', './a.css, ./b.css, ./c.css']);
+            expect(result.preserve).toEqual(['./a.css', './b.css', './c.css']);
+        });
+        it('should parse --prefix option', () => {
+            const result = parseArgs(['--prefix', './lib/']);
+            expect(result.prefix).toBe('./lib/');
+        });
+        it('should parse --strip option', () => {
+            const result = parseArgs(['--strip', 'generated']);
+            expect(result.strip).toBe('generated');
+        });
+        it('should parse multiple options together', () => {
+            const result = parseArgs([
+                '--dist',
+                'output',
+                '--preserve',
+                './styles.css',
+                '--strip',
+                'src',
+            ]);
+            expect(result).toEqual({
+                dist: 'output',
+                prefix: './',
+                preserve: ['./styles.css'],
+                strip: 'src',
+            });
+        });
+        it('should ignore unknown options', () => {
+            const result = parseArgs(['--unknown', 'value', '--dist', 'build']);
+            expect(result.dist).toBe('build');
+        });
+    });
+    describe('generateExportName', () => {
+        it('should convert .js path to export name', () => {
+            expect(generateExportName('foo.js', '')).toBe('./foo');
+        });
+        it('should handle nested paths', () => {
+            expect(generateExportName('utils/helpers.js', '')).toBe('./utils/helpers');
+        });
+        it('should strip /index suffix', () => {
+            expect(generateExportName('components/button/index.js', '')).toBe('./components/button');
+        });
+        it('should apply strip prefix', () => {
+            expect(generateExportName('generated/icons/arrow.js', 'generated')).toBe('./icons/arrow');
+        });
+        it('should handle strip with leading slash', () => {
+            expect(generateExportName('generated/icons/arrow.js', 'generated/')).toBe('./icons/arrow');
+        });
+        it('should handle index.js at root', () => {
+            expect(generateExportName('index.js', '')).toBe('./index');
+        });
+        it('should handle deeply nested index files', () => {
+            expect(generateExportName('a/b/c/index.js', '')).toBe('./a/b/c');
+        });
+    });
+});

package/dist/vitest/node.d.ts

@@ -1,3 +1,9 @@
 import type { TestUserConfig } from 'vitest/node';
+export declare const coverageThresholds: {
+    branches: number;
+    functions: number;
+    lines: number;
+    statements: number;
+};
 export declare const vitestNodeConfig: TestUserConfig;
 //# sourceMappingURL=node.d.ts.map

package/dist/vitest/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/vitest/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,eAAO,MAAM,gBAAgB,EAAE,cAK9B,CAAC"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/vitest/node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,eAAO,MAAM,kBAAkB;;;;;CAK9B,CAAC;AAMF,eAAO,MAAM,gBAAgB,EAAE,cAS9B,CAAC"}

package/dist/vitest/node.js

@@ -1,4 +1,14 @@
+export const coverageThresholds = {
+    branches: 80,
+    functions: 80,
+    lines: 80,
+    statements: 80,
+};
 export const vitestNodeConfig = {
+    coverage: {
+        provider: 'v8',
+        thresholds: coverageThresholds,
+    },
     environment: 'node',
     exclude: ['node_modules', 'dist', 'build', '.turbo', '.react-router'],
     globals: true,

package/dist/vitest/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/vitest/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAQlD,eAAO,MAAM,iBAAiB,EAAE,cAM/B,CAAC"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/vitest/react.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AASlD,eAAO,MAAM,iBAAiB,EAAE,cAU/B,CAAC"}

package/dist/vitest/react.js

@@ -1,4 +1,9 @@
+import { coverageThresholds } from './node';
 export const vitestReactConfig = {
+    coverage: {
+        provider: 'v8',
+        thresholds: coverageThresholds,
+    },
     environment: 'jsdom',
     exclude: ['node_modules', 'dist', 'build', '.turbo', '.react-router'],
     globals: true,

package/package.json

@@ -1,6 +1,60 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
+  "name": "@regardio/dev",
+  "version": "1.11.0",
+  "private": false,
+  "description": "Regardio developer tooling for testing, linting, and build workflows",
+  "keywords": [
+    "biome",
+    "changesets",
+    "commitlint",
+    "dev",
+    "husky",
+    "linting",
+    "markdownlint",
+    "playwright",
+    "testing",
+    "tooling",
+    "typescript",
+    "vitest"
+  ],
+  "homepage": "https://github.com/regardio/dev/blob/main/README.md",
+  "bugs": {
+    "url": "https://github.com/regardio/dev/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regardio/dev.git"
+  },
+  "license": "MIT",
   "author": "Bernd Matzner <bernd.matzner@regard.io>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "./biome": "./src/biome/preset.json",
+    "./commitlint": "./src/commitlint/commitlint.cjs",
+    "./markdownlint": "./src/markdownlint/markdownlint.json",
+    "./markdownlint-cli2": "./src/markdownlint/markdownlint-cli2.jsonc",
+    "./playwright": {
+      "types": "./dist/playwright/index.d.ts",
+      "default": "./dist/playwright/index.js"
+    },
+    "./testing/setup-react": {
+      "types": "./dist/testing/setup-react.d.ts",
+      "default": "./dist/testing/setup-react.js"
+    },
+    "./typescript/base.json": "./src/typescript/base.json",
+    "./typescript/build.json": "./src/typescript/build.json",
+    "./typescript/react.json": "./src/typescript/react.json",
+    "./vitest/node": {
+      "types": "./dist/vitest/node.d.ts",
+      "default": "./dist/vitest/node.js"
+    },
+    "./vitest/react": {
+      "types": "./dist/vitest/react.d.ts",
+      "default": "./dist/vitest/react.js"
+    }
+  },
   "bin": {
     "exec-clean": "dist/bin/exec-clean.js",
     "exec-husky": "dist/bin/exec-husky.js",
@@ -13,10 +67,30 @@
     "lint-biome": "dist/bin/lint-biome.js",
     "lint-commit": "dist/bin/lint-commit.js",
     "lint-md": "dist/bin/lint-md.js",
+    "lint-package": "dist/bin/lint-package.js",
     "post-build-exports": "dist/bin/post-build-exports.js"
   },
-  "bugs": {
-    "url": "https://github.com/regardio/dev/issues"
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "tsx src/bin/exec-clean.ts .turbo dist",
+    "fix": "run-p fix:*",
+    "fix:biome": "biome check --write --unsafe .",
+    "fix:md": "markdownlint-cli2 --fix \"**/*.md\" \"**/*.mdx\" \"!**/node_modules/**\" \"!**/dist/**\"",
+    "fix:pkg": "tsx src/bin/lint-package.ts",
+    "lint": "run-p lint:*",
+    "lint:biome": "biome check .",
+    "lint:md": "markdownlint-cli2 \"**/*.md\" \"**/*.mdx\" \"!**/node_modules/**\" \"!**/dist/**\"",
+    "prepare": "husky",
+    "release": "tsx src/bin/flow-release.ts",
+    "report": "vitest run --coverage",
+    "test": "run-p test:*",
+    "test:unit": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "version": "tsx src/bin/flow-changeset.ts version"
   },
   "dependencies": {
     "@biomejs/biome": "2.3.11",
@@ -29,6 +103,7 @@
     "@testing-library/react": "16.3.1",
     "@total-typescript/ts-reset": "0.6.1",
     "@types/node": "25.0.3",
+    "@vitest/coverage-v8": "4.0.16",
     "@vitest/ui": "4.0.16",
     "husky": "9.1.7",
     "jsdom": "27.4.0",
@@ -36,58 +111,12 @@
     "npm-run-all": "4.1.5",
     "postcss": "8.5.6",
     "rimraf": "6.1.2",
+    "sort-package-json": "3.1.0",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
     "vite": "7.3.1",
     "vitest": "4.0.16"
   },
-  "description": "Regardio developer tooling for testing, linting, and build workflows",
-  "engines": {
-    "node": ">=18"
-  },
-  "exports": {
-    "./biome": "./src/biome/preset.json",
-    "./commitlint": "./src/commitlint/commitlint.cjs",
-    "./markdownlint": "./src/markdownlint/markdownlint.json",
-    "./markdownlint-cli2": "./src/markdownlint/markdownlint-cli2.jsonc",
-    "./playwright": {
-      "default": "./dist/playwright/index.js",
-      "types": "./dist/playwright/index.d.ts"
-    },
-    "./testing/setup-react": {
-      "default": "./dist/testing/setup-react.js",
-      "types": "./dist/testing/setup-react.d.ts"
-    },
-    "./typescript/base.json": "./src/typescript/base.json",
-    "./typescript/build.json": "./src/typescript/build.json",
-    "./typescript/react.json": "./src/typescript/react.json",
-    "./vitest/node": {
-      "default": "./dist/vitest/node.js",
-      "types": "./dist/vitest/node.d.ts"
-    },
-    "./vitest/react": {
-      "default": "./dist/vitest/react.js",
-      "types": "./dist/vitest/react.d.ts"
-    }
-  },
-  "files": ["dist", "src"],
-  "homepage": "https://github.com/regardio/dev/blob/main/README.md",
-  "keywords": [
-    "biome",
-    "changesets",
-    "commitlint",
-    "dev",
-    "husky",
-    "linting",
-    "markdownlint",
-    "playwright",
-    "testing",
-    "tooling",
-    "typescript",
-    "vitest"
-  ],
-  "license": "MIT",
-  "name": "@regardio/dev",
   "peerDependencies": {
     "postcss": "8.4"
   },
@@ -96,30 +125,10 @@
       "optional": true
     }
   },
-  "private": false,
+  "engines": {
+    "node": ">=18"
+  },
   "publishConfig": {
     "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/regardio/dev.git"
-  },
-  "scripts": {
-    "build": "pnpm exec tsc -p tsconfig.build.json",
-    "clean": "pnpm exec tsx src/bin/exec-clean.ts .turbo dist",
-    "fix": "exec-p fix:*",
-    "fix:biome": "biome check --write --unsafe .",
-    "fix:md": "markdownlint-cli2 --fix \"**/*.md\" \"**/*.mdx\" \"!**/node_modules/**\" \"!**/dist/**\"",
-    "lint": "run-p lint:*",
-    "lint:biome": "biome check .",
-    "lint:md": "markdownlint-cli2 \"**/*.md\" \"**/*.mdx\" \"!**/node_modules/**\" \"!**/dist/**\"",
-    "prepare": "husky",
-    "release": "pnpm exec tsx src/bin/flow-release.ts",
-    "test": "run-p test:*",
-    "test:unit": "vitest run",
-    "version": "flow-changeset version"
-  },
-  "sideEffects": false,
-  "type": "module",
-  "version": "1.10.3"
+  }
 }

package/src/bin/flow-release.ts

@@ -70,6 +70,18 @@ if (!packageName) {
 
 console.log(`Releasing ${packageName} with ${bumpType} bump...`);
 
+// Run quality checks before release
+console.log('Running quality checks...');
+try {
+  run('pnpm build');
+  run('pnpm typecheck');
+  run('pnpm report');
+} catch {
+  console.error('Quality checks failed. Fix issues before releasing.');
+  process.exit(1);
+}
+console.log('✅ Quality checks passed');
+
 // Ensure we're in a clean git state
 try {
   const status = runQuiet('git status --porcelain');

package/src/bin/lint-package.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest';
+
+/**
+ * Reorder exports conditions: types must come before default for TypeScript.
+ * Extracted from lint-package.ts for testing.
+ */
+function reorderConditions(obj: Record<string, unknown>): Record<string, unknown> {
+  function processObject(o: Record<string, unknown>): Record<string, unknown> {
+    if (typeof o !== 'object' || o === null) return o;
+
+    // First, recursively process all nested objects
+    const processed: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(o)) {
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        processed[key] = processObject(value as Record<string, unknown>);
+      } else {
+        processed[key] = value;
+      }
+    }
+
+    // Then check if this object has both 'types' and 'default' keys
+    if ('types' in processed && 'default' in processed) {
+      const keys = Object.keys(processed);
+      const typesIndex = keys.indexOf('types');
+      const defaultIndex = keys.indexOf('default');
+
+      // If default comes before types, reorder
+      if (defaultIndex < typesIndex) {
+        const reordered: Record<string, unknown> = {};
+        reordered.types = processed.types;
+        for (const key of keys) {
+          if (key !== 'types') {
+            reordered[key] = processed[key];
+          }
+        }
+        return reordered;
+      }
+    }
+
+    return processed;
+  }
+
+  return processObject(obj);
+}
+
+describe('lint-package', () => {
+  describe('reorderConditions', () => {
+    it('should reorder types before default when default comes first', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
+    });
+
+    it('should not modify when types already comes before default', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./foo'] as Record<string, unknown>)).toEqual(['types', 'default']);
+    });
+
+    it('should handle multiple exports with mixed order', () => {
+      const input = {
+        './a': {
+          default: './dist/a.js',
+          types: './dist/a.d.ts',
+        },
+        './b': {
+          default: './dist/b.js',
+          types: './dist/b.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+
+      expect(Object.keys(result['./a'] as Record<string, unknown>)[0]).toBe('types');
+      expect(Object.keys(result['./b'] as Record<string, unknown>)[0]).toBe('types');
+    });
+
+    it('should preserve other keys after types', () => {
+      const input = {
+        './foo': {
+          default: './dist/foo.js',
+          import: './dist/foo.mjs',
+          require: './dist/foo.cjs',
+          types: './dist/foo.d.ts',
+        },
+      };
+
+      const result = reorderConditions(input);
+      const keys = Object.keys(result['./foo'] as Record<string, unknown>);
+
+      expect(keys[0]).toBe('types');
+      expect(keys.slice(1)).toEqual(['default', 'import', 'require']);
+    });
+
+    it('should handle exports without types or default', () => {
+      const input = {
+        './styles.css': './dist/styles.css',
+      };
+
+      const result = reorderConditions(input);
+
+      expect(result).toEqual(input);
+    });
+
+    it('should handle deeply nested condition objects', () => {
+      const input = {
+        './foo': {
+          browser: {
+            default: './dist/foo.browser.js',
+            types: './dist/foo.browser.d.ts',
+          },
+          node: {
+            default: './dist/foo.node.js',
+            types: './dist/foo.node.d.ts',
+          },
+        },
+      };
+
+      const result = reorderConditions(input);
+      const foo = result['./foo'] as Record<string, Record<string, unknown>>;
+
+      expect(Object.keys(foo.node as object)[0]).toBe('types');
+      expect(Object.keys(foo.browser as object)[0]).toBe('types');
+    });
+  });
+});

package/src/bin/lint-package.ts

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Sorts package.json files using sort-package-json and fixes
+ * exports condition order (types must come before default for TypeScript).
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const devRoot = resolve(__dirname, '../..');
+
+// Find sort-package-json binary
+const sortPkgBin = join(devRoot, 'node_modules/.bin/sort-package-json');
+const sortPkgBinAlt = join(devRoot, 'node_modules/sort-package-json/cli.js');
+
+let bin = '';
+if (existsSync(sortPkgBin)) {
+  bin = sortPkgBin;
+} else if (existsSync(sortPkgBinAlt)) {
+  bin = `node ${sortPkgBinAlt}`;
+} else {
+  bin = 'npx sort-package-json';
+}
+
+// Get args passed to this script
+const args = process.argv.slice(2);
+const files = args.length > 0 ? args : ['package.json'];
+
+// Run sort-package-json
+try {
+  execSync(`${bin} ${files.join(' ')}`, { stdio: 'inherit' });
+} catch {
+  process.exit(1);
+}
+
+/**
+ * Fix exports condition order: types must come before default for TypeScript.
+ * See: https://www.typescriptlang.org/docs/handbook/esm-node.html
+ */
+function fixExportsOrder(filePath: string): void {
+  const fullPath = resolve(process.cwd(), filePath);
+  if (!existsSync(fullPath)) return;
+
+  const content = readFileSync(fullPath, 'utf-8');
+  const pkg = JSON.parse(content) as Record<string, unknown>;
+
+  if (!pkg.exports || typeof pkg.exports !== 'object') return;
+
+  let modified = false;
+
+  function reorderConditions(obj: Record<string, unknown>): Record<string, unknown> {
+    if (typeof obj !== 'object' || obj === null) return obj;
+
+    // Check if this object has both 'types' and 'default' keys
+    if ('types' in obj && 'default' in obj) {
+      const keys = Object.keys(obj);
+      const typesIndex = keys.indexOf('types');
+      const defaultIndex = keys.indexOf('default');
+
+      // If default comes before types, reorder
+      if (defaultIndex < typesIndex) {
+        modified = true;
+        const reordered: Record<string, unknown> = {};
+        // Put types first, then all other keys in original order
+        reordered.types = obj.types;
+        for (const key of keys) {
+          if (key !== 'types') {
+            reordered[key] = obj[key];
+          }
+        }
+        return reordered;
+      }
+    }
+
+    // Recursively process nested objects
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        result[key] = reorderConditions(value as Record<string, unknown>);
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+
+  pkg.exports = reorderConditions(pkg.exports as Record<string, unknown>);
+
+  if (modified) {
+    writeFileSync(fullPath, `${JSON.stringify(pkg, null, 2)}\n`);
+  }
+}
+
+// Fix exports order in each file
+for (const file of files) {
+  fixExportsOrder(file);
+}

package/src/bin/post-build-exports.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest';
+
+/**
+ * Parse command line arguments for post-build-exports.
+ * Extracted from post-build-exports.ts for testing.
+ */
+function parseArgs(args: string[]): {
+  dist: string;
+  preserve: string[];
+  prefix: string;
+  strip: string;
+} {
+  const result = {
+    dist: 'dist',
+    prefix: './',
+    preserve: [] as string[],
+    strip: '',
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+
+    if (arg === '--dist' && next) {
+      result.dist = next;
+      i++;
+    } else if (arg === '--preserve' && next) {
+      result.preserve = next.split(',').map((p) => p.trim());
+      i++;
+    } else if (arg === '--prefix' && next) {
+      result.prefix = next;
+      i++;
+    } else if (arg === '--strip' && next) {
+      result.strip = next;
+      i++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generate export name from JS file path.
+ * Extracted from post-build-exports.ts for testing.
+ */
+function generateExportName(jsPath: string, strip: string): string {
+  let exportPath = jsPath.replace(/\.js$/, '');
+
+  if (strip && exportPath.startsWith(strip)) {
+    exportPath = exportPath.slice(strip.length);
+    if (exportPath.startsWith('/')) {
+      exportPath = exportPath.slice(1);
+    }
+  }
+
+  // Strip /index suffix for cleaner exports
+  if (exportPath.endsWith('/index')) {
+    exportPath = exportPath.slice(0, -6);
+  }
+
+  return `./${exportPath}`;
+}
+
+describe('post-build-exports', () => {
+  describe('parseArgs', () => {
+    it('should return defaults when no args provided', () => {
+      const result = parseArgs([]);
+
+      expect(result).toEqual({
+        dist: 'dist',
+        prefix: './',
+        preserve: [],
+        strip: '',
+      });
+    });
+
+    it('should parse --dist option', () => {
+      const result = parseArgs(['--dist', 'build']);
+
+      expect(result.dist).toBe('build');
+    });
+
+    it('should parse --preserve option with single value', () => {
+      const result = parseArgs(['--preserve', './tailwind.css']);
+
+      expect(result.preserve).toEqual(['./tailwind.css']);
+    });
+
+    it('should parse --preserve option with multiple comma-separated values', () => {
+      const result = parseArgs(['--preserve', './a.css, ./b.css, ./c.css']);
+
+      expect(result.preserve).toEqual(['./a.css', './b.css', './c.css']);
+    });
+
+    it('should parse --prefix option', () => {
+      const result = parseArgs(['--prefix', './lib/']);
+
+      expect(result.prefix).toBe('./lib/');
+    });
+
+    it('should parse --strip option', () => {
+      const result = parseArgs(['--strip', 'generated']);
+
+      expect(result.strip).toBe('generated');
+    });
+
+    it('should parse multiple options together', () => {
+      const result = parseArgs([
+        '--dist',
+        'output',
+        '--preserve',
+        './styles.css',
+        '--strip',
+        'src',
+      ]);
+
+      expect(result).toEqual({
+        dist: 'output',
+        prefix: './',
+        preserve: ['./styles.css'],
+        strip: 'src',
+      });
+    });
+
+    it('should ignore unknown options', () => {
+      const result = parseArgs(['--unknown', 'value', '--dist', 'build']);
+
+      expect(result.dist).toBe('build');
+    });
+  });
+
+  describe('generateExportName', () => {
+    it('should convert .js path to export name', () => {
+      expect(generateExportName('foo.js', '')).toBe('./foo');
+    });
+
+    it('should handle nested paths', () => {
+      expect(generateExportName('utils/helpers.js', '')).toBe('./utils/helpers');
+    });
+
+    it('should strip /index suffix', () => {
+      expect(generateExportName('components/button/index.js', '')).toBe('./components/button');
+    });
+
+    it('should apply strip prefix', () => {
+      expect(generateExportName('generated/icons/arrow.js', 'generated')).toBe('./icons/arrow');
+    });
+
+    it('should handle strip with leading slash', () => {
+      expect(generateExportName('generated/icons/arrow.js', 'generated/')).toBe('./icons/arrow');
+    });
+
+    it('should handle index.js at root', () => {
+      expect(generateExportName('index.js', '')).toBe('./index');
+    });
+
+    it('should handle deeply nested index files', () => {
+      expect(generateExportName('a/b/c/index.js', '')).toBe('./a/b/c');
+    });
+  });
+});

package/src/biome/preset.json

@@ -32,6 +32,7 @@
   },
   "files": {
     "ignoreUnknown": false,
+    "includes": ["**", "!**/package.json"],
     "maxSize": 1048576
   },
   "formatter": {

package/src/templates/release.yml

@@ -52,6 +52,12 @@ jobs:
       - name: Build
         run: pnpm build
 
+      - name: Type check
+        run: pnpm typecheck
+
+      - name: Test with coverage
+        run: pnpm report
+
       - name: Publish to npm
         id: publish
         run: |

package/src/vitest/node.ts

@@ -1,10 +1,25 @@
 import type { TestUserConfig } from 'vitest/node';
 
+/**
+ * Coverage thresholds for library packages.
+ * These ensure adequate test coverage before publishing.
+ */
+export const coverageThresholds = {
+  branches: 80,
+  functions: 80,
+  lines: 80,
+  statements: 80,
+};
+
 /**
  * Base Vitest configuration for Node.js packages.
  * Use with defineConfig() in your vitest.config.ts
  */
 export const vitestNodeConfig: TestUserConfig = {
+  coverage: {
+    provider: 'v8',
+    thresholds: coverageThresholds,
+  },
   environment: 'node',
   exclude: ['node_modules', 'dist', 'build', '.turbo', '.react-router'],
   globals: true,

package/src/vitest/react.ts

@@ -1,4 +1,5 @@
 import type { TestUserConfig } from 'vitest/node';
+import { coverageThresholds } from './node';
 
 /**
  * Vitest configuration for React packages with jsdom environment.
@@ -7,6 +8,10 @@ import type { TestUserConfig } from 'vitest/node';
  * Requires a setup file that imports '@testing-library/jest-dom/vitest'
  */
 export const vitestReactConfig: TestUserConfig = {
+  coverage: {
+    provider: 'v8',
+    thresholds: coverageThresholds,
+  },
   environment: 'jsdom',
   exclude: ['node_modules', 'dist', 'build', '.turbo', '.react-router'],
   globals: true,