@dbtlr/tooling 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# @dbtlr/tooling
+
+Shared Vite+ config for Drew's TypeScript projects — one `toolingConfig()` entry point.
+
+## Quick start
+
+One call describes what the project is and returns a finished Vite+ config:
+
+```ts
+// vite.config.ts
+import { toolingConfig } from '@dbtlr/tooling';
+
+export default toolingConfig({ react: true }); // browser React app
+```
+
+Intent flags fan out to lint, test, and Vite config. Every project shape is a single `toolingConfig` call:
+
+| Project                | Call                                                                       |
+| ---------------------- | -------------------------------------------------------------------------- |
+| Node server            | `toolingConfig({ node: true })`                                            |
+| Browser React app      | `toolingConfig({ react: true })`                                           |
+| Isomorphic React (SSR) | `toolingConfig({ node: true, react: true })`                               |
+| Published library      | `toolingConfig({ pack: { entry: ['src/index.ts'] } })`                     |
+| Node CLI / package     | `toolingConfig({ node: true, pack: { entry: ['src/cli.ts'] } })`           |
+| Monorepo root          | `toolingConfig({ node: ['packages/api/**'], react: ['packages/web/**'] })` |
+
+See [`examples/`](./examples) for runnable, CI-verified versions of each.
+
+### How intent maps to config
+
+- `node` — Node lint target (allows `node:` builtins) + node test env.
+- `react` — React lint plugins + modern-JSX rules + PascalCase filenames, jsdom test env, and the Vite react-app block.
+- `node` + `react` — isomorphic: both lint targets, jsdom test.
+- `pack` present — buildable/publishable package (adds the `pack` block).
+- `test` — override the derived env (`'node'` / `'react'`) or omit it (`false`).
+
+`node`/`react` accept `boolean | string[]`. **A boolean configures the whole project; a glob list scopes the target to those files** (a `files`-scoped oxlint override) and marks a **monorepo root** — lint is centralized and no project-wide test/Vite block is added (members own those). This is how one root config addresses each package's runtime in a vite-plus monorepo (whose `pnpm-workspace.yaml` centralizes lint config).
+
+`toolingConfig` also accepts the Vite+ options (`lint` / `fmt` / `staged` / `pack`) as overrides on top of the derived defaults. (`node`/`react` are canonical at the top level, so they're not repeated under `lint`.)
+
+### Strict by default
+
+Lint is **strict by default** — warnings fail (`denyWarnings`) and type-aware lint + type checking run (`typeAware`, `typeCheck`). Opt out per-flag via the `lint` override, e.g. `toolingConfig({ react: true, lint: { typeCheck: false } })`.
+
+## TypeScript presets
+
+```json
+{
+  "extends": "@dbtlr/tooling/tsconfig/node.json",
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}
+```
+
+Available presets:
+
+- `@dbtlr/tooling/tsconfig/base.json`
+- `@dbtlr/tooling/tsconfig/node.json`
+- `@dbtlr/tooling/tsconfig/bun.json`
+- `@dbtlr/tooling/tsconfig/react.json`
+- `@dbtlr/tooling/tsconfig/monorepo.json`
+- `@dbtlr/tooling/tsconfig/vitest.json`
+
+## Granular helpers (escape hatch)
+
+`toolingConfig` composes these; reach for them directly when you need finer control — e.g. a monorepo **member** package, or passing Vite plugins. Each is its own subpath export:
+
+- `vitePlusBase` / `vitePlusPackage` (`@dbtlr/tooling/vite-plus`) — lint/fmt/staged, plus a `pack` block for buildable packages. `node`/`react` live under the `lint` option here. Strict by default.
+- `vitestNode` / `vitestReact` (`@dbtlr/tooling/vitest`) — Vitest project config (node / jsdom).
+- `viteReactApp` (`@dbtlr/tooling/vite`) — the Vite react-app block; pass `plugins: [react()]` for a real dev/build server.
+
+```ts
+import { defineConfig } from 'vite-plus';
+import { vitePlusPackage } from '@dbtlr/tooling/vite-plus';
+import { vitestNode } from '@dbtlr/tooling/vitest';
+
+export default defineConfig({
+  ...vitePlusPackage({ lint: { node: true }, pack: { entry: ['src/index.ts'] } }),
+  ...vitestNode(),
+});
+```
+
+Linting and formatting are delivered through Vite+ (`vp lint` / `vp fmt`), which bundles Oxlint — there is no standalone Oxlint subpath.
+
+## Dependency policy
+
+`@dbtlr/tooling` declares its tool integrations (`vite`, `vite-plus`) as **optional peer dependencies** — install the ones your config uses. `vite-plus` powers the whole toolchain (build / lint / fmt / test via `vp`).
+
+## Verification
+
+```bash
+pnpm install
+pnpm run check
+pnpm run pack:dry
+```

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+import { n as JsonPrimitive, r as JsonValue, t as JsonObject } from "./types-55c3OwME.mjs";
+import { VitePlusLintOptions, vitePlusBase, vitePlusPackage } from "./vite-plus.mjs";
+import { vitestNode, vitestReact } from "./vitest.mjs";
+import { viteReactApp } from "./vite.mjs";
+
+//#region src/tooling-config.d.ts
+type LintTarget = boolean | readonly string[];
+type ToolingConfigOptions = {
+  readonly node?: LintTarget;
+  readonly react?: LintTarget;
+  readonly test?: 'node' | 'react' | false;
+  readonly pack?: JsonObject;
+  readonly lint?: Omit<VitePlusLintOptions, 'node' | 'react'>;
+  readonly fmt?: JsonObject;
+  readonly staged?: JsonObject | false;
+};
+declare const toolingConfig: (options?: ToolingConfigOptions) => import("vite-plus").UserConfig;
+//#endregion
+export { type JsonObject, type JsonPrimitive, type JsonValue, type ToolingConfigOptions, toolingConfig, vitePlusBase, vitePlusPackage, viteReactApp, vitestNode, vitestReact };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/tooling-config.ts"],"mappings":";;;;;;KASK,UAAA;AAAA,KAEA,oBAAA;EAAA,SACM,IAAA,GAAO,UAAA;EAAA,SACP,KAAA,GAAQ,UAAA;EAAA,SACR,IAAA;EAAA,SACA,IAAA,GAAO,UAAA;EAAA,SACP,IAAA,GAAO,IAAA,CAAK,mBAAA;EAAA,SACZ,GAAA,GAAM,UAAA;EAAA,SACN,MAAA,GAAS,UAAA;AAAA;AAAA,cAOd,aAAA,GAAiB,OAAA,GAAS,oBAAyB,yBAAA,UAAA"}

package/dist/index.mjs

@@ -0,0 +1,38 @@
+import { t as compactObject } from "./types-DnGmJhKp.mjs";
+import { vitePlusBase, vitePlusPackage } from "./vite-plus.mjs";
+import { viteReactApp } from "./vite.mjs";
+import { vitestNode, vitestReact } from "./vitest.mjs";
+import { defineConfig } from "vite-plus";
+//#region src/tooling-config.ts
+const isScopedTarget = (target) => Array.isArray(target);
+const toolingConfig = (options = {}) => {
+	const { node, react, test, pack, lint, fmt, staged } = options;
+	const scoped = isScopedTarget(node) || isScopedTarget(react);
+	const baseOptions = compactObject({
+		fmt,
+		lint: {
+			...lint,
+			node,
+			react
+		},
+		staged
+	});
+	const base = pack === void 0 ? vitePlusBase(baseOptions) : vitePlusPackage({
+		...baseOptions,
+		pack
+	});
+	const viteApp = react === true && !scoped ? viteReactApp() : {};
+	const testBlock = (() => {
+		if (scoped || test === false) return {};
+		return (test ?? (react ? "react" : "node")) === "react" ? vitestReact() : vitestNode();
+	})();
+	return defineConfig({
+		...base,
+		...viteApp,
+		...testBlock
+	});
+};
+//#endregion
+export { toolingConfig, vitePlusBase, vitePlusPackage, viteReactApp, vitestNode, vitestReact };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/tooling-config.ts"],"sourcesContent":["import { defineConfig } from 'vite-plus';\n\nimport { compactObject } from './types.js';\nimport type { JsonObject } from './types.js';\nimport { vitePlusBase, vitePlusPackage } from './vite-plus.js';\nimport type { VitePlusLintOptions } from './vite-plus.js';\nimport { viteReactApp } from './vite.js';\nimport { vitestNode, vitestReact } from './vitest.js';\n\ntype LintTarget = boolean | readonly string[];\n\ntype ToolingConfigOptions = {\n  readonly node?: LintTarget;\n  readonly react?: LintTarget;\n  readonly test?: 'node' | 'react' | false;\n  readonly pack?: JsonObject;\n  readonly lint?: Omit<VitePlusLintOptions, 'node' | 'react'>;\n  readonly fmt?: JsonObject;\n  readonly staged?: JsonObject | false;\n};\n\n// A glob list scopes a target to a monorepo's packages; a bare `true` means the\n// whole single project. Globs => this is a monorepo root: lint only, no test/vite.\nconst isScopedTarget = (target: LintTarget | undefined): boolean => Array.isArray(target);\n\nconst toolingConfig = (options: ToolingConfigOptions = {}) => {\n  const { node, react, test, pack, lint, fmt, staged } = options;\n  const scoped = isScopedTarget(node) || isScopedTarget(react);\n\n  const baseOptions = compactObject({\n    fmt,\n    lint: { ...lint, node, react },\n    staged,\n  });\n  const base =\n    pack === undefined ? vitePlusBase(baseOptions) : vitePlusPackage({ ...baseOptions, pack });\n\n  // Single-project react gets the vite react-app block; a monorepo root (any glob\n  // target) does not — gated on `scoped` so it stays consistent with the test block.\n  const viteApp = react === true && !scoped ? viteReactApp() : {};\n\n  // Derive the test env from intent unless overridden; monorepo roots and\n  // `test: false` carry no test block (members own their own test config).\n  const testBlock = ((): JsonObject => {\n    if (scoped || test === false) {\n      return {};\n    }\n    const env = test ?? (react ? 'react' : 'node');\n    return env === 'react' ? vitestReact() : vitestNode();\n  })();\n\n  return defineConfig({ ...base, ...viteApp, ...testBlock });\n};\n\nexport { toolingConfig };\nexport type { ToolingConfigOptions };\n"],"mappings":";;;;;;AAuBA,MAAM,kBAAkB,WAA4C,MAAM,QAAQ,MAAM;AAExF,MAAM,iBAAiB,UAAgC,CAAC,MAAM;CAC5D,MAAM,EAAE,MAAM,OAAO,MAAM,MAAM,MAAM,KAAK,WAAW;CACvD,MAAM,SAAS,eAAe,IAAI,KAAK,eAAe,KAAK;CAE3D,MAAM,cAAc,cAAc;EAChC;EACA,MAAM;GAAE,GAAG;GAAM;GAAM;EAAM;EAC7B;CACF,CAAC;CACD,MAAM,OACJ,SAAS,KAAA,IAAY,aAAa,WAAW,IAAI,gBAAgB;EAAE,GAAG;EAAa;CAAK,CAAC;CAI3F,MAAM,UAAU,UAAU,QAAQ,CAAC,SAAS,aAAa,IAAI,CAAC;CAI9D,MAAM,mBAA+B;EACnC,IAAI,UAAU,SAAS,OACrB,OAAO,CAAC;EAGV,QADY,SAAS,QAAQ,UAAU,aACxB,UAAU,YAAY,IAAI,WAAW;CACtD,EAAA,CAAG;CAEH,OAAO,aAAa;EAAE,GAAG;EAAM,GAAG;EAAS,GAAG;CAAU,CAAC;AAC3D"}

package/dist/types-55c3OwME.d.mts

@@ -0,0 +1,9 @@
+//#region src/types.d.ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonValue[];
+type JsonObject = {
+  readonly [key: string]: JsonValue | undefined;
+};
+//#endregion
+export { JsonPrimitive as n, JsonValue as r, JsonObject as t };
+//# sourceMappingURL=types-55c3OwME.d.mts.map

package/dist/types-55c3OwME.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-55c3OwME.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAK,aAAA;AAAA,KACA,SAAA,GAAY,aAAA,GAAgB,UAAA,GAAa,SAAA;AAAA,KACzC,UAAA;EAAA,UAAyB,GAAA,WAAc,SAAS;AAAA"}

package/dist/types-DnGmJhKp.mjs

@@ -0,0 +1,6 @@
+//#region src/types.ts
+const compactObject = (value) => Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+//#endregion
+export { compactObject as t };
+
+//# sourceMappingURL=types-DnGmJhKp.mjs.map

package/dist/types-DnGmJhKp.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-DnGmJhKp.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["type JsonPrimitive = string | number | boolean | null;\ntype JsonValue = JsonPrimitive | JsonObject | JsonValue[];\ntype JsonObject = { readonly [key: string]: JsonValue | undefined };\n\ntype DeepPartial<Type> = {\n  [Key in keyof Type]?: Type[Key] extends object ? DeepPartial<Type[Key]> : Type[Key];\n};\n\n// Dropping only undefined-valued keys preserves Type's shape, so the assertion is safe.\nconst compactObject = <Type extends Record<string, unknown>>(value: Type): Type =>\n  // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n  Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as Type;\n\nexport { compactObject };\nexport type { DeepPartial, JsonObject, JsonPrimitive, JsonValue };\n"],"mappings":";AASA,MAAM,iBAAuD,UAE3D,OAAO,YAAY,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,CAAS,CAAC"}

package/dist/vite-plus.d.mts

@@ -0,0 +1,26 @@
+import { t as JsonObject } from "./types-55c3OwME.mjs";
+
+//#region src/vite-plus.d.ts
+type LintTarget = boolean | readonly string[];
+type VitePlusLintOptions = {
+  readonly typeAware?: boolean;
+  readonly typeCheck?: boolean;
+  readonly denyWarnings?: boolean;
+  readonly maxWarnings?: number;
+  readonly ignores?: readonly string[];
+  readonly node?: LintTarget;
+  readonly react?: LintTarget;
+  readonly rules?: JsonObject;
+  readonly overrides?: readonly JsonObject[];
+};
+type VitePlusPackageOptions = {
+  readonly pack?: JsonObject;
+  readonly lint?: VitePlusLintOptions;
+  readonly fmt?: JsonObject;
+  readonly staged?: JsonObject | false;
+};
+declare const vitePlusBase: (options?: VitePlusPackageOptions) => JsonObject;
+declare const vitePlusPackage: (options?: VitePlusPackageOptions) => JsonObject;
+//#endregion
+export { type VitePlusLintOptions, type VitePlusPackageOptions, vitePlusBase, vitePlusPackage };
+//# sourceMappingURL=vite-plus.d.mts.map

package/dist/vite-plus.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plus.d.mts","names":[],"sources":["../src/vite-plus.ts"],"mappings":";;;KAQK,UAAA;AAAA,KAEA,mBAAA;EAAA,SACM,SAAA;EAAA,SACA,SAAA;EAAA,SACA,YAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA;EAAA,SACA,IAAA,GAAO,UAAA;EAAA,SACP,KAAA,GAAQ,UAAA;EAAA,SACR,KAAA,GAAQ,UAAA;EAAA,SACR,SAAA,YAAqB,UAAA;AAAA;AAAA,KAsC3B,sBAAA;EAAA,SACM,IAAA,GAAO,UAAA;EAAA,SACP,IAAA,GAAO,mBAAA;EAAA,SACP,GAAA,GAAM,UAAA;EAAA,SACN,MAAA,GAAS,UAAA;AAAA;AAAA,cA4Gd,YAAA,GAAgB,OAAA,GAAS,sBAAA,KAA8B,UAmBzD;AAAA,cAEE,eAAA,GAAmB,OAAA,GAAS,sBAAA,KAA8B,UAO9D"}

package/dist/vite-plus.mjs

@@ -0,0 +1,137 @@
+import { t as compactObject } from "./types-DnGmJhKp.mjs";
+//#region src/vite-plus.ts
+const REACT_PLUGINS = [
+	"react",
+	"react-perf",
+	"jsx-a11y"
+];
+const REACT_RULES = {
+	"react/react-in-jsx-scope": "off",
+	"unicorn/filename-case": ["warn", { cases: {
+		kebabCase: true,
+		pascalCase: true
+	} }]
+};
+const NODE_PLUGINS = ["node"];
+const NODE_RULES = { "import/no-nodejs-modules": "off" };
+const isWholeProject = (target) => target === true;
+const targetGlobs = (target) => Array.isArray(target) && target.length > 0 ? target : void 0;
+const scopedOverride = (globs, plugins, rules) => ({
+	files: [...globs],
+	plugins: [...plugins],
+	rules: { ...rules }
+});
+const vitePlusLint = (options = {}) => {
+	const nodeWhole = isWholeProject(options.node);
+	const reactWhole = isWholeProject(options.react);
+	const nodeGlobs = targetGlobs(options.node);
+	const reactGlobs = targetGlobs(options.react);
+	const targetOverrides = [...nodeGlobs ? [scopedOverride(nodeGlobs, NODE_PLUGINS, NODE_RULES)] : [], ...reactGlobs ? [scopedOverride(reactGlobs, REACT_PLUGINS, REACT_RULES)] : []];
+	return {
+		categories: {
+			correctness: "error",
+			nursery: "off",
+			pedantic: "off",
+			perf: "error",
+			restriction: "off",
+			style: "warn",
+			suspicious: "error"
+		},
+		ignorePatterns: [
+			"node_modules",
+			"dist",
+			"build",
+			"coverage",
+			".turbo",
+			".vite",
+			...options.ignores ?? []
+		],
+		options: compactObject({
+			denyWarnings: options.denyWarnings ?? true,
+			maxWarnings: options.maxWarnings,
+			typeAware: options.typeAware ?? true,
+			typeCheck: options.typeCheck ?? true
+		}),
+		overrides: [
+			...targetOverrides,
+			{
+				files: [
+					"tests/**/*.ts",
+					"tests/**/*.tsx",
+					"**/*.test.ts",
+					"**/*.test.tsx",
+					"**/*.spec.ts",
+					"**/*.spec.tsx"
+				],
+				rules: {
+					"max-statements": "off",
+					"vitest/no-importing-vitest-globals": "off",
+					"vitest/prefer-expect-assertions": "off",
+					"vitest/prefer-importing-vitest-globals": "off"
+				}
+			},
+			...options.overrides ?? []
+		],
+		plugins: [
+			"typescript",
+			"import",
+			"eslint",
+			"unicorn",
+			"oxc",
+			"promise",
+			"vitest",
+			...nodeWhole ? NODE_PLUGINS : [],
+			...reactWhole ? REACT_PLUGINS : []
+		],
+		rules: {
+			"capitalized-comments": "off",
+			"import/no-named-export": "off",
+			"import/no-nodejs-modules": "error",
+			"import/prefer-default-export": "off",
+			"no-duplicate-imports": ["warn", { allowSeparateTypeImports: true }],
+			"no-magic-numbers": "off",
+			"no-ternary": "off",
+			"sort-imports": "off",
+			"typescript/consistent-type-definitions": ["warn", "type"],
+			"unicorn/no-null": "off",
+			"unicorn/prefer-ternary": "off",
+			"vitest/prefer-importing-vitest-globals": "off",
+			"vitest/prefer-to-be-falsy": "off",
+			"vitest/prefer-to-be-truthy": "off",
+			...nodeWhole ? NODE_RULES : {},
+			...reactWhole ? REACT_RULES : {},
+			...options.rules
+		}
+	};
+};
+const vitePlusBase = (options = {}) => compactObject({
+	fmt: {
+		ignorePatterns: [
+			"pnpm-lock.yaml",
+			"bun.lock",
+			"dist/**",
+			"build/**",
+			"node_modules/**",
+			"coverage/**",
+			".turbo/**",
+			".vite/**"
+		],
+		singleQuote: true,
+		sortImports: { ignoreCase: true },
+		...options.fmt
+	},
+	lint: vitePlusLint(options.lint),
+	staged: options.staged === false ? void 0 : options.staged ?? { "*": "vp check --fix" }
+});
+const vitePlusPackage = (options = {}) => ({
+	...vitePlusBase(options),
+	pack: {
+		dts: { tsgo: true },
+		exports: true,
+		...options.pack
+	}
+});
+//#endregion
+export { vitePlusBase, vitePlusPackage };
+
+//# sourceMappingURL=vite-plus.mjs.map

package/dist/vite-plus.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-plus.mjs","names":[],"sources":["../src/vite-plus.ts"],"sourcesContent":["import { compactObject } from './types.js';\nimport type { JsonObject } from './types.js';\n\n// A lint target — `node` or `react` — is a set of files the target applies to.\n// `true` means the whole project (config emitted at the top level); a list of\n// globs means just those files (config emitted as a scoped `overrides` fragment),\n// which is how a mixed-target monorepo's centralized root config addresses each\n// package. `false`/omitted/`[]` means the target is off.\ntype LintTarget = boolean | readonly string[];\n\ntype VitePlusLintOptions = {\n  readonly typeAware?: boolean;\n  readonly typeCheck?: boolean;\n  readonly denyWarnings?: boolean;\n  readonly maxWarnings?: number;\n  readonly ignores?: readonly string[];\n  readonly node?: LintTarget;\n  readonly react?: LintTarget;\n  readonly rules?: JsonObject;\n  readonly overrides?: readonly JsonObject[];\n};\n\n// oxlint plugins enabled for a React target; the `react` plugin also carries the\n// rules-of-hooks / exhaustive-deps checks.\nconst REACT_PLUGINS = ['react', 'react-perf', 'jsx-a11y'] as const;\n\n// The rule tweaks a React target needs: the modern automatic JSX runtime (no\n// in-scope React import) and PascalCase component filenames.\nconst REACT_RULES: JsonObject = {\n  'react/react-in-jsx-scope': 'off',\n  'unicorn/filename-case': ['warn', { cases: { kebabCase: true, pascalCase: true } }],\n};\n\n// oxlint plugins enabled for a Node target.\nconst NODE_PLUGINS = ['node'] as const;\n\n// The rule a Node target needs: allow Node builtins (forbidden by the browser\n// baseline). Enabled alongside the `node` plugin. Consumed by both the\n// whole-project and glob-scoped node paths so they can't drift.\nconst NODE_RULES: JsonObject = {\n  'import/no-nodejs-modules': 'off',\n};\n\n// A target is \"whole project\" only when explicitly `true`.\nconst isWholeProject = (target: LintTarget | undefined): boolean => target === true;\n\n// Non-empty glob list → the target is scoped to those files; otherwise undefined.\nconst targetGlobs = (target: LintTarget | undefined): readonly string[] | undefined =>\n  Array.isArray(target) && target.length > 0 ? target : undefined;\n\n// Build the scoped `overrides` fragment for a glob-targeted plugin set + rules.\nconst scopedOverride = (\n  globs: readonly string[],\n  plugins: readonly string[],\n  rules: JsonObject,\n): JsonObject => ({ files: [...globs], plugins: [...plugins], rules: { ...rules } });\n\ntype VitePlusPackageOptions = {\n  readonly pack?: JsonObject;\n  readonly lint?: VitePlusLintOptions;\n  readonly fmt?: JsonObject;\n  readonly staged?: JsonObject | false;\n};\n\nconst vitePlusLint = (options: VitePlusLintOptions = {}): JsonObject => {\n  const nodeWhole = isWholeProject(options.node);\n  const reactWhole = isWholeProject(options.react);\n  const nodeGlobs = targetGlobs(options.node);\n  const reactGlobs = targetGlobs(options.react);\n\n  // Glob-scoped targets become `overrides` fragments; they precede the standing\n  // test-file override and any caller-supplied overrides.\n  const targetOverrides: JsonObject[] = [\n    ...(nodeGlobs ? [scopedOverride(nodeGlobs, NODE_PLUGINS, NODE_RULES)] : []),\n    ...(reactGlobs ? [scopedOverride(reactGlobs, REACT_PLUGINS, REACT_RULES)] : []),\n  ];\n\n  return {\n    categories: {\n      correctness: 'error',\n      nursery: 'off',\n      pedantic: 'off',\n      perf: 'error',\n      restriction: 'off',\n      style: 'warn',\n      suspicious: 'error',\n    },\n    ignorePatterns: [\n      'node_modules',\n      'dist',\n      'build',\n      'coverage',\n      '.turbo',\n      '.vite',\n      ...(options.ignores ?? []),\n    ],\n    // Strict by default: warnings fail, and type-aware lint + type checking run.\n    // This is the house gate; opt out of any of them per-flag with `false`.\n    options: compactObject({\n      denyWarnings: options.denyWarnings ?? true,\n      maxWarnings: options.maxWarnings,\n      typeAware: options.typeAware ?? true,\n      typeCheck: options.typeCheck ?? true,\n    }),\n    overrides: [\n      ...targetOverrides,\n      {\n        files: [\n          'tests/**/*.ts',\n          'tests/**/*.tsx',\n          '**/*.test.ts',\n          '**/*.test.tsx',\n          '**/*.spec.ts',\n          '**/*.spec.tsx',\n        ],\n        rules: {\n          'max-statements': 'off',\n          'vitest/no-importing-vitest-globals': 'off',\n          'vitest/prefer-expect-assertions': 'off',\n          'vitest/prefer-importing-vitest-globals': 'off',\n        },\n      },\n      ...(options.overrides ?? []),\n    ],\n    plugins: [\n      'typescript',\n      'import',\n      'eslint',\n      'unicorn',\n      'oxc',\n      'promise',\n      'vitest',\n      // Whole-project targets enable plugins here; glob-scoped targets enable them\n      // in their `overrides` fragment instead (see targetOverrides).\n      ...(nodeWhole ? NODE_PLUGINS : []),\n      ...(reactWhole ? REACT_PLUGINS : []),\n    ],\n    rules: {\n      'capitalized-comments': 'off',\n      'import/no-named-export': 'off',\n      // Browser baseline forbids Node builtins; a whole-project node target lifts\n      // this via NODE_RULES below, a glob-scoped one only inside its override.\n      'import/no-nodejs-modules': 'error',\n      // Named exports are the house style (see import/no-named-export above), so\n      // don't nudge single-export modules toward a default export.\n      'import/prefer-default-export': 'off',\n      'no-duplicate-imports': ['warn', { allowSeparateTypeImports: true }],\n      'no-magic-numbers': 'off',\n      'no-ternary': 'off',\n      'sort-imports': 'off',\n      'typescript/consistent-type-definitions': ['warn', 'type'],\n      'unicorn/no-null': 'off',\n      // Ternaries are allowed (no-ternary off) but not forced; prefer-ternary would\n      // rewrite else-if chains into nested ternaries, conflicting with unicorn/no-nested-ternary.\n      'unicorn/prefer-ternary': 'off',\n      'vitest/prefer-importing-vitest-globals': 'off',\n      // Conflicts with vitest/prefer-strict-boolean-matchers; prefer strict toBe(true|false).\n      // Disabled at base (not just in test files) so the conflict can't fire anywhere.\n      'vitest/prefer-to-be-falsy': 'off',\n      'vitest/prefer-to-be-truthy': 'off',\n      // Whole-project targets only; glob-scoped rules live in their overrides.\n      // Spread last so a whole-project node target overrides the baseline above.\n      ...(nodeWhole ? NODE_RULES : {}),\n      ...(reactWhole ? REACT_RULES : {}),\n      ...options.rules,\n    },\n  };\n};\n\nconst vitePlusBase = (options: VitePlusPackageOptions = {}): JsonObject =>\n  compactObject({\n    fmt: {\n      ignorePatterns: [\n        'pnpm-lock.yaml',\n        'bun.lock',\n        'dist/**',\n        'build/**',\n        'node_modules/**',\n        'coverage/**',\n        '.turbo/**',\n        '.vite/**',\n      ],\n      singleQuote: true,\n      sortImports: { ignoreCase: true },\n      ...options.fmt,\n    },\n    lint: vitePlusLint(options.lint),\n    staged: options.staged === false ? undefined : (options.staged ?? { '*': 'vp check --fix' }),\n  });\n\nconst vitePlusPackage = (options: VitePlusPackageOptions = {}): JsonObject => ({\n  ...vitePlusBase(options),\n  pack: {\n    dts: { tsgo: true },\n    exports: true,\n    ...options.pack,\n  },\n});\n\nexport { vitePlusBase, vitePlusPackage };\nexport type { VitePlusLintOptions, VitePlusPackageOptions };\n"],"mappings":";;AAwBA,MAAM,gBAAgB;CAAC;CAAS;CAAc;AAAU;AAIxD,MAAM,cAA0B;CAC9B,4BAA4B;CAC5B,yBAAyB,CAAC,QAAQ,EAAE,OAAO;EAAE,WAAW;EAAM,YAAY;CAAK,EAAE,CAAC;AACpF;AAGA,MAAM,eAAe,CAAC,MAAM;AAK5B,MAAM,aAAyB,EAC7B,4BAA4B,MAC9B;AAGA,MAAM,kBAAkB,WAA4C,WAAW;AAG/E,MAAM,eAAe,WACnB,MAAM,QAAQ,MAAM,KAAK,OAAO,SAAS,IAAI,SAAS,KAAA;AAGxD,MAAM,kBACJ,OACA,SACA,WACgB;CAAE,OAAO,CAAC,GAAG,KAAK;CAAG,SAAS,CAAC,GAAG,OAAO;CAAG,OAAO,EAAE,GAAG,MAAM;AAAE;AASlF,MAAM,gBAAgB,UAA+B,CAAC,MAAkB;CACtE,MAAM,YAAY,eAAe,QAAQ,IAAI;CAC7C,MAAM,aAAa,eAAe,QAAQ,KAAK;CAC/C,MAAM,YAAY,YAAY,QAAQ,IAAI;CAC1C,MAAM,aAAa,YAAY,QAAQ,KAAK;CAI5C,MAAM,kBAAgC,CACpC,GAAI,YAAY,CAAC,eAAe,WAAW,cAAc,UAAU,CAAC,IAAI,CAAC,GACzE,GAAI,aAAa,CAAC,eAAe,YAAY,eAAe,WAAW,CAAC,IAAI,CAAC,CAC/E;CAEA,OAAO;EACL,YAAY;GACV,aAAa;GACb,SAAS;GACT,UAAU;GACV,MAAM;GACN,aAAa;GACb,OAAO;GACP,YAAY;EACd;EACA,gBAAgB;GACd;GACA;GACA;GACA;GACA;GACA;GACA,GAAI,QAAQ,WAAW,CAAC;EAC1B;EAGA,SAAS,cAAc;GACrB,cAAc,QAAQ,gBAAgB;GACtC,aAAa,QAAQ;GACrB,WAAW,QAAQ,aAAa;GAChC,WAAW,QAAQ,aAAa;EAClC,CAAC;EACD,WAAW;GACT,GAAG;GACH;IACE,OAAO;KACL;KACA;KACA;KACA;KACA;KACA;IACF;IACA,OAAO;KACL,kBAAkB;KAClB,sCAAsC;KACtC,mCAAmC;KACnC,0CAA0C;IAC5C;GACF;GACA,GAAI,QAAQ,aAAa,CAAC;EAC5B;EACA,SAAS;GACP;GACA;GACA;GACA;GACA;GACA;GACA;GAGA,GAAI,YAAY,eAAe,CAAC;GAChC,GAAI,aAAa,gBAAgB,CAAC;EACpC;EACA,OAAO;GACL,wBAAwB;GACxB,0BAA0B;GAG1B,4BAA4B;GAG5B,gCAAgC;GAChC,wBAAwB,CAAC,QAAQ,EAAE,0BAA0B,KAAK,CAAC;GACnE,oBAAoB;GACpB,cAAc;GACd,gBAAgB;GAChB,0CAA0C,CAAC,QAAQ,MAAM;GACzD,mBAAmB;GAGnB,0BAA0B;GAC1B,0CAA0C;GAG1C,6BAA6B;GAC7B,8BAA8B;GAG9B,GAAI,YAAY,aAAa,CAAC;GAC9B,GAAI,aAAa,cAAc,CAAC;GAChC,GAAG,QAAQ;EACb;CACF;AACF;AAEA,MAAM,gBAAgB,UAAkC,CAAC,MACvD,cAAc;CACZ,KAAK;EACH,gBAAgB;GACd;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EACF;EACA,aAAa;EACb,aAAa,EAAE,YAAY,KAAK;EAChC,GAAG,QAAQ;CACb;CACA,MAAM,aAAa,QAAQ,IAAI;CAC/B,QAAQ,QAAQ,WAAW,QAAQ,KAAA,IAAa,QAAQ,UAAU,EAAE,KAAK,iBAAiB;AAC5F,CAAC;AAEH,MAAM,mBAAmB,UAAkC,CAAC,OAAmB;CAC7E,GAAG,aAAa,OAAO;CACvB,MAAM;EACJ,KAAK,EAAE,MAAM,KAAK;EAClB,SAAS;EACT,GAAG,QAAQ;CACb;AACF"}

package/dist/vite.d.mts

@@ -0,0 +1,13 @@
+import { r as JsonValue, t as JsonObject } from "./types-55c3OwME.mjs";
+
+//#region src/vite.d.ts
+type ViteReactAppOptions = {
+  readonly plugins?: readonly JsonValue[];
+  readonly alias?: JsonObject;
+  readonly server?: JsonObject;
+  readonly test?: JsonObject;
+};
+declare const viteReactApp: (options?: ViteReactAppOptions) => JsonObject;
+//#endregion
+export { type ViteReactAppOptions, viteReactApp };
+//# sourceMappingURL=vite.d.mts.map

package/dist/vite.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.mts","names":[],"sources":["../src/vite.ts"],"mappings":";;;KAEK,mBAAA;EAAA,SACM,OAAA,YAAmB,SAAA;EAAA,SACnB,KAAA,GAAQ,UAAA;EAAA,SACR,MAAA,GAAS,UAAA;EAAA,SACT,IAAA,GAAO,UAAA;AAAA;AAAA,cAGZ,YAAA,GAAgB,OAAA,GAAS,mBAAA,KAA2B,UAKxD"}

package/dist/vite.mjs

@@ -0,0 +1,11 @@
+//#region src/vite.ts
+const viteReactApp = (options = {}) => ({
+	plugins: options.plugins ? [...options.plugins] : [],
+	resolve: options.alias ? { alias: options.alias } : void 0,
+	server: options.server,
+	test: options.test
+});
+//#endregion
+export { viteReactApp };
+
+//# sourceMappingURL=vite.mjs.map

package/dist/vite.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.mjs","names":[],"sources":["../src/vite.ts"],"sourcesContent":["import type { JsonObject, JsonValue } from './types.js';\n\ntype ViteReactAppOptions = {\n  readonly plugins?: readonly JsonValue[];\n  readonly alias?: JsonObject;\n  readonly server?: JsonObject;\n  readonly test?: JsonObject;\n};\n\nconst viteReactApp = (options: ViteReactAppOptions = {}): JsonObject => ({\n  plugins: options.plugins ? [...options.plugins] : [],\n  resolve: options.alias ? { alias: options.alias } : undefined,\n  server: options.server,\n  test: options.test,\n});\n\nexport { viteReactApp };\nexport type { ViteReactAppOptions };\n"],"mappings":";AASA,MAAM,gBAAgB,UAA+B,CAAC,OAAmB;CACvE,SAAS,QAAQ,UAAU,CAAC,GAAG,QAAQ,OAAO,IAAI,CAAC;CACnD,SAAS,QAAQ,QAAQ,EAAE,OAAO,QAAQ,MAAM,IAAI,KAAA;CACpD,QAAQ,QAAQ;CAChB,MAAM,QAAQ;AAChB"}

package/dist/vitest.d.mts

@@ -0,0 +1,17 @@
+import { t as JsonObject } from "./types-55c3OwME.mjs";
+
+//#region src/vitest.d.ts
+type VitestProjectOptions = {
+  readonly name?: string;
+  readonly include?: readonly string[];
+  readonly exclude?: readonly string[];
+  readonly setupFiles?: readonly string[];
+  readonly globals?: boolean;
+  readonly coverage?: JsonObject | false;
+};
+type VitestEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'browser';
+declare const vitestNode: (options?: VitestProjectOptions) => JsonObject;
+declare const vitestReact: (options?: VitestProjectOptions) => JsonObject;
+//#endregion
+export { type VitestEnvironment, type VitestProjectOptions, vitestNode, vitestReact };
+//# sourceMappingURL=vitest.d.mts.map

package/dist/vitest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.d.mts","names":[],"sources":["../src/vitest.ts"],"mappings":";;;KAGK,oBAAA;EAAA,SACM,IAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,GAAW,UAAU;AAAA;AAAA,KAG3B,iBAAA;AAAA,cAkBC,UAAA,GAAc,OAAA,GAAS,oBAAA,KAA4B,UACkB;AAAA,cAErE,WAAA,GAAe,OAAA,GAAS,oBAAA,KAA4B,UAItD"}

package/dist/vitest.mjs

@@ -0,0 +1,20 @@
+import { t as compactObject } from "./types-DnGmJhKp.mjs";
+//#region src/vitest.ts
+const vitestConfig = (environment, options, defaultInclude) => ({ test: compactObject({
+	coverage: options.coverage === false ? void 0 : options.coverage,
+	environment,
+	exclude: options.exclude ? [...options.exclude] : void 0,
+	globals: options.globals,
+	include: [...options.include ?? defaultInclude],
+	name: options.name,
+	setupFiles: options.setupFiles ? [...options.setupFiles] : void 0
+}) });
+const vitestNode = (options = {}) => vitestConfig("node", options, ["src/**/*.test.ts", "tests/**/*.test.ts"]);
+const vitestReact = (options = {}) => vitestConfig("jsdom", {
+	globals: true,
+	...options
+}, ["src/**/*.test.{ts,tsx}", "tests/**/*.test.{ts,tsx}"]);
+//#endregion
+export { vitestNode, vitestReact };
+
+//# sourceMappingURL=vitest.mjs.map

package/dist/vitest.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.mjs","names":[],"sources":["../src/vitest.ts"],"sourcesContent":["import { compactObject } from './types.js';\nimport type { JsonObject } from './types.js';\n\ntype VitestProjectOptions = {\n  readonly name?: string;\n  readonly include?: readonly string[];\n  readonly exclude?: readonly string[];\n  readonly setupFiles?: readonly string[];\n  readonly globals?: boolean;\n  readonly coverage?: JsonObject | false;\n};\n\ntype VitestEnvironment = 'node' | 'jsdom' | 'happy-dom' | 'browser';\n\nconst vitestConfig = (\n  environment: VitestEnvironment,\n  options: VitestProjectOptions,\n  defaultInclude: readonly string[],\n): JsonObject => ({\n  test: compactObject({\n    coverage: options.coverage === false ? undefined : options.coverage,\n    environment,\n    exclude: options.exclude ? [...options.exclude] : undefined,\n    globals: options.globals,\n    include: [...(options.include ?? defaultInclude)],\n    name: options.name,\n    setupFiles: options.setupFiles ? [...options.setupFiles] : undefined,\n  }),\n});\n\nconst vitestNode = (options: VitestProjectOptions = {}): JsonObject =>\n  vitestConfig('node', options, ['src/**/*.test.ts', 'tests/**/*.test.ts']);\n\nconst vitestReact = (options: VitestProjectOptions = {}): JsonObject =>\n  vitestConfig('jsdom', { globals: true, ...options }, [\n    'src/**/*.test.{ts,tsx}',\n    'tests/**/*.test.{ts,tsx}',\n  ]);\n\nexport { vitestNode, vitestReact };\nexport type { VitestEnvironment, VitestProjectOptions };\n"],"mappings":";;AAcA,MAAM,gBACJ,aACA,SACA,oBACgB,EAChB,MAAM,cAAc;CAClB,UAAU,QAAQ,aAAa,QAAQ,KAAA,IAAY,QAAQ;CAC3D;CACA,SAAS,QAAQ,UAAU,CAAC,GAAG,QAAQ,OAAO,IAAI,KAAA;CAClD,SAAS,QAAQ;CACjB,SAAS,CAAC,GAAI,QAAQ,WAAW,cAAe;CAChD,MAAM,QAAQ;CACd,YAAY,QAAQ,aAAa,CAAC,GAAG,QAAQ,UAAU,IAAI,KAAA;AAC7D,CAAC,EACH;AAEA,MAAM,cAAc,UAAgC,CAAC,MACnD,aAAa,QAAQ,SAAS,CAAC,oBAAoB,oBAAoB,CAAC;AAE1E,MAAM,eAAe,UAAgC,CAAC,MACpD,aAAa,SAAS;CAAE,SAAS;CAAM,GAAG;AAAQ,GAAG,CACnD,0BACA,0BACF,CAAC"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@dbtlr/tooling",
+  "version": "0.1.0",
+  "description": "Shared TypeScript, Vitest, and Vite+ config for dbtlr projects — one toolingConfig() entry point.",
+  "homepage": "https://github.com/dbtlr/ts-tooling#readme",
+  "bugs": "https://github.com/dbtlr/ts-tooling/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dbtlr/ts-tooling.git"
+  },
+  "files": [
+    "dist",
+    "tsconfig",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./vitest": {
+      "types": "./dist/vitest.d.mts",
+      "default": "./dist/vitest.mjs"
+    },
+    "./vite-plus": {
+      "types": "./dist/vite-plus.d.mts",
+      "default": "./dist/vite-plus.mjs"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.mts",
+      "default": "./dist/vite.mjs"
+    },
+    "./tsconfig/base.json": "./tsconfig/base.json",
+    "./tsconfig/node.json": "./tsconfig/node.json",
+    "./tsconfig/bun.json": "./tsconfig/bun.json",
+    "./tsconfig/react.json": "./tsconfig/react.json",
+    "./tsconfig/monorepo.json": "./tsconfig/monorepo.json",
+    "./tsconfig/vitest.json": "./tsconfig/vitest.json",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0",
+    "vite-plus": "^0.2.1"
+  },
+  "peerDependencies": {
+    "vite": ">=7.0.0",
+    "vite-plus": ">=0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    },
+    "vite-plus": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "lint": "vp lint",
+    "format": "vp fmt",
+    "fmt:check": "vp fmt --check",
+    "test": "vp test",
+    "check": "vp check && vp test && vp pack",
+    "check:examples": "bash scripts/check-examples.sh",
+    "pack:dry": "pnpm pack --dry-run"
+  }
+}

package/tsconfig/base.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext"],
+    "moduleDetection": "force",
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "noUncheckedIndexedAccess": true,
+    "noFallthroughCasesInSwitch": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

package/tsconfig/bun.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "module": "Preserve",
+    "moduleResolution": "Bundler",
+    "types": ["bun"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true
+  }
+}

package/tsconfig/monorepo.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "types": ["node"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "exactOptionalPropertyTypes": true
+  }
+}

package/tsconfig/node.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "types": ["node"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  }
+}

package/tsconfig/react.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./base.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "types": ["vite/client"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true
+  }
+}

package/tsconfig/vitest.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./node.json",
+  "compilerOptions": {
+    "types": ["node", "vitest/globals"]
+  }
+}