@storm-software/eslint 0.170.156 → 0.170.158

package/dist/types.mjs

@@ -0,0 +1,5 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { ConfigNames, RuleOptions } from "./typegen.d.mts";
+export { ConfigNames, RuleOptions };

package/dist/utils/correct-paths.mjs

@@ -0,0 +1,136 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+//#region src/utils/correct-paths.ts
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const correctPaths = function(path) {
+	if (!path || path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const joinPaths = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return correctPaths(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+/**
+* Resolves a string path, resolving '.' and '.' segments and allowing paths above the root.
+*
+* @param path - The path to normalise.
+* @param allowAboveRoot - Whether to allow the resulting path to be above the root directory.
+* @returns the normalised path string.
+*/
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1) {} else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+//#endregion
+export { correctPaths, isAbsolute, joinPaths, normalizeString, normalizeWindowsPath, relative, resolve };

package/dist/utils/find-workspace-root.mjs

@@ -0,0 +1,83 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { correctPaths } from "./correct-paths.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/utils/find-workspace-root.ts
+const MAX_PATH_SEARCH_DEPTH = 30;
+let depth = 0;
+/**
+* Gets the nearest "node_modules" folder by walking up from start path.
+*/
+function findFolderUp(startPath, endFileNames = [], endDirectoryNames = []) {
+	const _startPath = startPath ?? process.cwd();
+	if (endDirectoryNames.some((endDirName) => existsSync(join(_startPath, endDirName)))) return _startPath;
+	if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) return _startPath;
+	if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) return findFolderUp(join(_startPath, ".."), endFileNames, endDirectoryNames);
+}
+const rootFiles = [
+	"storm-workspace.json",
+	"storm-workspace.json",
+	"storm-workspace.yaml",
+	"storm-workspace.yml",
+	"storm-workspace.js",
+	"storm-workspace.ts",
+	".storm-workspace.json",
+	".storm-workspace.yaml",
+	".storm-workspace.yml",
+	".storm-workspace.js",
+	".storm-workspace.ts",
+	"lerna.json",
+	"nx.json",
+	"turbo.json",
+	"npm-workspace.json",
+	"yarn-workspace.json",
+	"pnpm-workspace.json",
+	"npm-workspace.yaml",
+	"yarn-workspace.yaml",
+	"pnpm-workspace.yaml",
+	"npm-workspace.yml",
+	"yarn-workspace.yml",
+	"pnpm-workspace.yml",
+	"npm-lock.json",
+	"yarn-lock.json",
+	"pnpm-lock.json",
+	"npm-lock.yaml",
+	"yarn-lock.yaml",
+	"pnpm-lock.yaml",
+	"npm-lock.yml",
+	"yarn-lock.yml",
+	"pnpm-lock.yml",
+	"bun.lockb"
+];
+const rootDirectories = [
+	".storm-workspace",
+	".nx",
+	".github",
+	".vscode",
+	".verdaccio"
+];
+/**
+* Find the monorepo root directory, searching upwards from `path`.
+*
+* @param pathInsideMonorepo - The path inside the monorepo to start searching from
+* @returns The monorepo root directory
+*/
+function findWorkspaceRootSafe(pathInsideMonorepo) {
+	if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) return correctPaths(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
+	return correctPaths(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles, rootDirectories));
+}
+/**
+* Find the monorepo root directory, searching upwards from `path`.
+*
+* @param pathInsideMonorepo - The path inside the monorepo to start searching from
+* @returns The monorepo root directory
+*/
+function findWorkspaceRoot(pathInsideMonorepo) {
+	const result = findWorkspaceRootSafe(pathInsideMonorepo);
+	if (!result) throw new Error(`Cannot find workspace root upwards from known path. Files search list includes: \n${rootFiles.join("\n")}\nPath: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`);
+	return result;
+}
+//#endregion
+export { findWorkspaceRoot, findWorkspaceRootSafe };

package/dist/utils/helpers.mjs

@@ -0,0 +1,75 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { isPackageExists } from "local-pkg";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+//#region src/utils/helpers.ts
+const scopeUrl = fileURLToPath(new URL(".", import.meta.url));
+const isCwdInScope = isPackageExists("@storm-software/eslint");
+const parserPlain = {
+	meta: { name: "parser-plain" },
+	parseForESLint: (code) => ({
+		ast: {
+			body: [],
+			comments: [],
+			loc: {
+				end: code.length,
+				start: 0
+			},
+			range: [0, code.length],
+			tokens: [],
+			type: "Program"
+		},
+		scopeManager: null,
+		services: { isPlain: true },
+		visitorKeys: { Program: [] }
+	})
+};
+function isInGitHooksOrLintStaged() {
+	return !!(process.env.GIT_PARAMS || process.env.VSCODE_GIT_COMMAND || process.env.npm_lifecycle_script?.startsWith("lint-staged") || process.env.npm_lifecycle_script?.startsWith("lefthook") || process.env.npm_lifecycle_script === "push");
+}
+function isInEditorEnv() {
+	if (process.env.CI) return false;
+	if (isInGitHooksOrLintStaged()) return false;
+	return !!(process.env.VSCODE_PID || process.env.VSCODE_CWD || process.env.JETBRAINS_IDE || process.env.VIM || process.env.NVIM);
+}
+async function interopDefault(m) {
+	const resolved = await m;
+	return resolved.default || resolved;
+}
+function isPackageInScope(name) {
+	return isPackageExists(name, { paths: [scopeUrl] });
+}
+async function ensurePackages(packages) {
+	if (process.env.CI || process.stdout.isTTY === false || isCwdInScope === false) return;
+	const nonExistingPackages = packages.filter((i) => i && !isPackageInScope(i));
+	if (nonExistingPackages.length === 0) return;
+	if (await (await import("@clack/prompts")).confirm({ message: `${nonExistingPackages.length === 1 ? "Package is" : "Packages are"} required for this config: ${nonExistingPackages.join(", ")}. Do you want to install them?` })) await import("@antfu/install-pkg").then((i) => i.installPackage(nonExistingPackages, { dev: true }));
+}
+/**
+* Rename plugin prefixes in a rule object.
+* Accepts a map of prefixes to rename.
+*
+* @example
+* ```ts
+* import { renameRules } from '@storm-software/eslint'
+*
+* export default [{
+*   rules: renameRules(
+*     {
+*       '@typescript-eslint/indent': 'error'
+*     },
+*     { '@typescript-eslint': 'ts' }
+*   )
+* }]
+* ```
+*/
+function renameRules(rules, map) {
+	return Object.fromEntries(Object.entries(rules).map(([key, value]) => {
+		for (const [from, to] of Object.entries(map)) if (key.startsWith(`${from}/`)) return [to + key.slice(from.length), value];
+		return [key, value];
+	}));
+}
+//#endregion
+export { ensurePackages, interopDefault, isInEditorEnv, isInGitHooksOrLintStaged, isPackageInScope, parserPlain, renameRules };

package/dist/utils/package-manager.mjs

@@ -0,0 +1,20 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { findWorkspaceRootSafe } from "./find-workspace-root.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/utils/package-manager.ts
+/**
+* Detect the package manager used in the workspace.
+*
+* @returns "pnpm" | "bun" | "npm"
+*/
+function detectPackageManager() {
+	const workspaceRoot = findWorkspaceRootSafe() ?? process.cwd();
+	if (existsSync(join(workspaceRoot, "bun.lockb")) || existsSync(join(workspaceRoot, "bun.lock")) || existsSync(join(workspaceRoot, "bunfig.toml")) || existsSync(join(workspaceRoot, "bunfig.yml"))) return "bun";
+	if (existsSync(join(workspaceRoot, "pnpm-lock.yaml")) || existsSync(join(workspaceRoot, "pnpm-lock.yml")) || existsSync(join(workspaceRoot, "pnpm-workpace.yaml"))) return "pnpm";
+	return "npm";
+}
+//#endregion
+export { detectPackageManager };

package/dist/utils/tsconfig.mjs

@@ -0,0 +1,48 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { joinPaths, relative } from "./correct-paths.mjs";
+import { findWorkspaceRoot } from "./find-workspace-root.mjs";
+import { existsSync, statSync } from "node:fs";
+//#region src/utils/tsconfig.ts
+/**
+* Gets the path to the nearest tsconfig file by walking up from start path.
+*
+* The search order is as follows:
+* 1. If `tsconfigPath` is provided and exists, it will be used.
+* 2. If a tsconfig file is found in the current working directory, it will be used.
+* 3. If a tsconfig file is found in the workspace root, it will be used.
+* 4. If no tsconfig file is found, a warning will be logged and a default path will be returned based on the project type (app or lib).
+*
+* The function checks for the following tsconfig file names in order:
+* - tsconfig.json
+* - tsconfig.base.json
+* - tsconfig.app.json
+* - tsconfig.lib.json
+* - tsconfig.eslint.json
+* - tsconfig.lint.json
+*
+* @param tsconfigPath Optional path to a tsconfig file. If provided, it will be used if it exists.
+* @param type The type of project (app or lib) to determine the default tsconfig file name if no tsconfig file is found. Default is "app".
+* @returns The path to the nearest tsconfig file relative to the workspace root.
+*/
+function getTsConfigPath(tsconfigPath, type) {
+	const workspaceRoot = findWorkspaceRoot();
+	if (tsconfigPath && existsSync(tsconfigPath) && statSync(tsconfigPath).isFile()) return relative(workspaceRoot, tsconfigPath);
+	let result = checkTsConfigPath(process.cwd());
+	if (result) return relative(workspaceRoot, joinPaths(process.cwd(), result));
+	result = checkTsConfigPath(workspaceRoot);
+	if (result) return relative(workspaceRoot, joinPaths(workspaceRoot, result));
+	console.warn(`No tsconfig.json found${tsconfigPath ? ` provided: ${tsconfigPath}` : ""}. Consider adding a tsconfig.json file to your project's ESLint configuration.`);
+	return workspaceRoot?.replace(/\\/g, "/").replaceAll(/\/$/g, "") === process.cwd().replace(/\\/g, "/").replaceAll(/\/$/g, "") ? "tsconfig.base.json" : type ? `tsconfig.${type}.json` : "tsconfig.json";
+}
+function checkTsConfigPath(root) {
+	if (existsSync(joinPaths(root, "tsconfig.json"))) return "tsconfig.json";
+	else if (existsSync(joinPaths(root, "tsconfig.base.json"))) return "tsconfig.base.json";
+	else if (existsSync(joinPaths(root, "tsconfig.app.json"))) return "tsconfig.app.json";
+	else if (existsSync(joinPaths(root, "tsconfig.lib.json"))) return "tsconfig.lib.json";
+	else if (existsSync(joinPaths(root, "tsconfig.eslint.json"))) return "tsconfig.eslint.json";
+	else if (existsSync(joinPaths(root, "tsconfig.lint.json"))) return "tsconfig.lint.json";
+}
+//#endregion
+export { checkTsConfigPath, getTsConfigPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/eslint",
-  "version": "0.170.156",
+  "version": "0.170.158",
   "private": false,
   "description": "A package containing the base ESLint configuration used by Storm Software across many projects.",
   "keywords": [
@@ -51,75 +51,54 @@
   "sideEffects": false,
   "type": "module",
   "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      },
-      "default": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
-    },
-    "./index": {
-      "import": { "types": "./dist/index.d.ts", "default": "./dist/index.js" },
-      "require": {
-        "types": "./dist/index.d.cts",
-        "default": "./dist/index.cjs"
-      },
-      "default": { "types": "./dist/index.d.ts", "default": "./dist/index.js" }
-    },
-    "./preset": {
-      "import": {
-        "types": "./dist/preset.d.ts",
-        "default": "./dist/preset.js"
-      },
-      "require": {
-        "types": "./dist/preset.d.cts",
-        "default": "./dist/preset.cjs"
-      },
-      "default": {
-        "types": "./dist/preset.d.ts",
-        "default": "./dist/preset.js"
-      }
-    },
-    "./types": {
-      "import": { "types": "./dist/types.d.ts", "default": "./dist/types.js" },
-      "require": {
-        "types": "./dist/types.d.cts",
-        "default": "./dist/types.cjs"
-      },
-      "default": { "types": "./dist/types.d.ts", "default": "./dist/types.js" }
-    },
-    "./rules/*": {
-      "import": {
-        "types": "./dist/rules/*.d.ts",
-        "default": "./dist/rules/*.js"
-      },
-      "require": {
-        "types": "./dist/rules/*.d.cts",
-        "default": "./dist/rules/*.cjs"
-      },
-      "default": {
-        "types": "./dist/rules/*.d.ts",
-        "default": "./dist/rules/*.js"
-      }
-    },
-    "./utils/*": {
-      "import": {
-        "types": "./dist/utils/*.d.ts",
-        "default": "./dist/utils/*.js"
-      },
-      "require": {
-        "types": "./dist/utils/*.d.cts",
-        "default": "./dist/utils/*.cjs"
-      },
-      "default": {
-        "types": "./dist/utils/*.d.ts",
-        "default": "./dist/utils/*.js"
-      }
-    }
+    ".": "./dist/index.mjs",
+    "./configs": "./dist/configs/index.mjs",
+    "./configs/astro": "./dist/configs/astro.mjs",
+    "./configs/banner": "./dist/configs/banner.mjs",
+    "./configs/bun": "./dist/configs/bun.mjs",
+    "./configs/cspell": "./dist/configs/cspell.mjs",
+    "./configs/disables": "./dist/configs/disables.mjs",
+    "./configs/formatters": "./dist/configs/formatters.mjs",
+    "./configs/graphql": "./dist/configs/graphql.mjs",
+    "./configs/ignores": "./dist/configs/ignores.mjs",
+    "./configs/imports": "./dist/configs/imports.mjs",
+    "./configs/javascript": "./dist/configs/javascript.mjs",
+    "./configs/jsdoc": "./dist/configs/jsdoc.mjs",
+    "./configs/jsonc": "./dist/configs/jsonc.mjs",
+    "./configs/jsx": "./dist/configs/jsx.mjs",
+    "./configs/markdown": "./dist/configs/markdown.mjs",
+    "./configs/mdx": "./dist/configs/mdx.mjs",
+    "./configs/next": "./dist/configs/next.mjs",
+    "./configs/node": "./dist/configs/node.mjs",
+    "./configs/nx": "./dist/configs/nx.mjs",
+    "./configs/perfectionist": "./dist/configs/perfectionist.mjs",
+    "./configs/pnpm": "./dist/configs/pnpm.mjs",
+    "./configs/prettier": "./dist/configs/prettier.mjs",
+    "./configs/react": "./dist/configs/react.mjs",
+    "./configs/react-native": "./dist/configs/react-native.mjs",
+    "./configs/regexp": "./dist/configs/regexp.mjs",
+    "./configs/secrets": "./dist/configs/secrets.mjs",
+    "./configs/sort": "./dist/configs/sort.mjs",
+    "./configs/storybook": "./dist/configs/storybook.mjs",
+    "./configs/stylistic": "./dist/configs/stylistic.mjs",
+    "./configs/test": "./dist/configs/test.mjs",
+    "./configs/toml": "./dist/configs/toml.mjs",
+    "./configs/tsdoc": "./dist/configs/tsdoc.mjs",
+    "./configs/typescript": "./dist/configs/typescript.mjs",
+    "./configs/unicorn": "./dist/configs/unicorn.mjs",
+    "./configs/unocss": "./dist/configs/unocss.mjs",
+    "./configs/yaml": "./dist/configs/yaml.mjs",
+    "./configs/zod": "./dist/configs/zod.mjs",
+    "./plugins": "./dist/plugins.mjs",
+    "./preset": "./dist/preset.mjs",
+    "./types": "./dist/types.mjs",
+    "./utils/correct-paths": "./dist/utils/correct-paths.mjs",
+    "./utils/find-workspace-root": "./dist/utils/find-workspace-root.mjs",
+    "./utils/helpers": "./dist/utils/helpers.mjs",
+    "./utils/package-manager": "./dist/utils/package-manager.mjs",
+    "./utils/tsconfig": "./dist/utils/tsconfig.mjs",
+    "./*": "./*"
   },
-  "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": ["dist"],
   "dependencies": {
@@ -129,11 +108,11 @@
     "@eslint/eslintrc": "^3.3.6",
     "@eslint/markdown": "^6.6.0",
     "@nx/eslint-plugin": "23.1.1",
-    "@storm-software/config": "1.138.59",
-    "@storm-software/config-tools": "1.190.122",
-    "@storm-software/eslint-plugin-banner": "0.0.87",
-    "@storm-software/eslint-plugin-tsdoc": "0.0.85",
-    "@storm-software/package-constants": "0.1.135",
+    "@storm-software/config": "1.138.61",
+    "@storm-software/config-tools": "1.190.124",
+    "@storm-software/eslint-plugin-banner": "0.0.89",
+    "@storm-software/eslint-plugin-tsdoc": "0.0.87",
+    "@storm-software/package-constants": "0.1.137",
     "@stylistic/eslint-plugin": "^4.4.1",
     "@typescript-eslint/eslint-plugin": "^8.66.0",
     "@typescript-eslint/parser": "^8.66.0",
@@ -189,9 +168,9 @@
     "@next/eslint-plugin-next": "^15.5.23",
     "@nx/eslint": "23.1.1",
     "@prettier/plugin-xml": "^3.4.2",
-    "@storm-software/eslint-plugin-bun": "0.0.10",
-    "@storm-software/eslint-plugin-pnpm": "0.0.85",
-    "@storm-software/tsdoc": "0.13.275",
+    "@storm-software/eslint-plugin-bun": "0.0.12",
+    "@storm-software/eslint-plugin-pnpm": "0.0.87",
+    "@storm-software/tsdoc": "0.13.277",
     "@stylistic/eslint-plugin-migrate": "^4.4.1",
     "@types/eslint": "^9.6.1",
     "@types/eslint__js": "^8.42.3",
@@ -222,7 +201,7 @@
     "graphql": "^16.14.2",
     "minimatch": "^10.2.6",
     "prettier-plugin-astro": "^0.14.1",
-    "tsup": "8.4.0",
+    "tsdown": "^0.22.14",
     "tsx": "^4.23.10",
     "typescript": "^6.0.3",
     "zod": "^4.4.3"
@@ -289,5 +268,5 @@
     "zod": { "optional": true }
   },
   "publishConfig": { "access": "public" },
-  "gitHead": "0be9a37f594450158c976638a8d496232ba3178a"
+  "gitHead": "88e28b2c74d1a37c7f613a2e4cb0bbfb20f785aa"
 }

package/dist/index.cjs

@@ -1,24 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var preset = require('./preset');
-var configs = require('./configs');
-
-var index_default = preset.defineConfig;
-
-exports.default = index_default;
-Object.keys(preset).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return preset[k]; }
-  });
-});
-Object.keys(configs).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return configs[k]; }
-  });
-});
-
-module.exports = exports.default;