@liangmi/vp-config 0.0.0 → 0.1.0

package/README.md

@@ -1,8 +1,6 @@
 # @liangmi/vp-config
 
-Liang's opinionated Vite+ config presets for JavaScript development, including linting, formatting, task running and more.
-
-It is designed to work with different kinds of project, cli / tui development, library, and website development (WIP, waiting for [Oxlint's better Vue support](https://github.com/oxc-project/oxc/issues/15761))
+Liang's united [Vite+](https://viteplus.dev/) config presets for JavaScript development — opinionated, strict and designed to be universal with different kinds of projects.
 
 ## Usage
 
@@ -15,15 +13,116 @@ vp install -D @liangmi/vp-config
 And modify your `vite.config.ts` like that:
 
 ```typescript
-import { cli } from "@liangmi/vp-config";
+import { base } from "@liangmi/vp-config";
+
+export default base({
+  /* Your personal config overrides, will be merged deeply */
+});
+```
+
+> [!WARNING]
+> Considering Vite+ is now still alpha, the internal API can be unstable and expected to change, please manage to use `@liangmi/vp-config` with the latest Vite+. If you found something that doesn't work expectedly, please [submit an issue](https://github.com/liangmiQwQ/vp-config/issues/new).
+
+### Categories
+
+We provide four config categories for different kinds of projects.
+
+| Category  | Description                                            | Recommended for      |
+| --------- | ------------------------------------------------------ | -------------------- |
+| `base`    | Pure and basic config                                  | Workspace root       |
+| `cli`     | Config for Node.js CLI and React/Vue Tui applications  | CLI and TUI projects |
+| `lib`     | Config with library bundling defaults                  | Libraries            |
+| `website` | Config for browser environment and website development | Websites             |
+
+The `website` category is experimental and its defaults may change before the package reaches a stable release. React and browser linting are available, but Vue template linting is still waiting for [better Vue support in Oxlint](https://github.com/oxc-project/oxc/issues/15761).
+
+For monorepos, different presets should be used in combination. We should use `base` the workspace root, and use other categories as needed.
+
+### Customizable
+
+Each category is a wrapper of Vite+'s `defineConfig`. The config passed to it overrides and deeply merges with the preset.
+
+> [!TIP]
+>
+> Deep merging means your config only needs to specify what should change. Nested preset options that you do not override remain enabled, while values from your config take precedence.
+
+Use `.only()` to load only selected parts of a preset:
+
+```typescript
+import { base } from "@liangmi/vp-config";
 
-export default cli({
-  /* Your personal config overrides */
+export default base.only(["lint", "fmt"], {
+  lint: {
+    /* Your own lint config */
+  },
+  fmt: {
+    /* Your own format config */
+  },
 });
 ```
 
-Considering Vite+ is now still alpha, the internal API can be unstable and expected to change, please manage to use `@liangmi/vp-config` with the latest Vite+. If you found something that doesn't work expectedly, please [submit an issue](https://github.com/liangmiQwQ/vp-config/issues/new).
+Use `.exclude()` to omit selected parts while keeping the rest:
+
+```typescript
+import { base } from "@liangmi/vp-config";
+
+export default base.exclude(["staged"], {});
+```
+
+Available config parts are `fmt`, `lint`, `pack`, `run`, and `staged`, depending on the selected category.
+
+## What's included by default
+
+Vite+ is a united toolchain for JavaScript development, it includes linting, formatting, library bundling, git hooks, test, task runner, website development, etc.
+
+`@liangmi/vp-config` tries to extract reusable configurations from these, in order to improve the development experience as much as possible.
+
+### Lint
+
+The lint config prioritizes correctness and fast feedback. Rules that prevent bugs report errors, while style and fixable readability rules generally report warnings and are left to autofixes. Warnings also fail the lint command, keeping the codebase consistent without treating every style concern as a hand-written task.
+
+All categories include a strict Oxlint config with type-aware linting and type checking enabled, which means you do not need to run `tsc` manually. Correctness, performance, suspicious, and nursery rules report errors.
+
+`console.log` is not allowed except in the `cli` category and Node.js script files. Test files enable Vitest rules, while the `cli` and `website` categories add React and Vue component rules. The `website` category also enables browser-specific rules.
+
+The included `liangmi` Oxlint plugin checks that presets are loaded correctly. It reports orphan `vite.config.ts` files, preset imports outside config files, missing preset wrappers, improper root or project categories, and configs that mix library and website signals.
+
+### Format
+
+The format config follows a simple philosophy: remove syntax that does not improve readability, and let the formatter handle mechanical consistency.
+
+All categories include an Oxfmt config using single quotes, no semicolons, no unnecessary trailing commas, sorted imports, and sorted `package.json` fields. Embedded-language formatting is disabled for `base` and `lib`, and enabled for `cli` and `website`.
+
+### Pack
+
+The packaging presets provide the best-practice defaults for each kind of project while leaving project-specific details explicit. Because the package entry depends on the project's source layout, you still need to define `pack.entry` manually.
+
+The `lib` preset generates `.d.ts` and package exports with fixed extensions. The `cli` preset targets Node.js, minifies output, strips `node:` protocol prefixes, and disables `dts` generation.
+
+### Cached commands
+
+In order to make full use of Vite+'s powerful cache system without too much config and make it contributors-friendly, we provide cached tasks task wrappers for common Vite+ commands. This feature is included in all categories.
+
+In most cases, they should be treated more like cached versions of Vite+ commands rather than normal user-defined tasks. For example, users can run `vpr ccheck` as a cached replacement for `vp check`.
+
+| Task      | Command     |
+| --------- | ----------- |
+| `cbuild`  | `vp build`  |
+| `cpack`   | `vp pack`   |
+| `clint`   | `vp lint`   |
+| `cfmt`    | `vp fmt`    |
+| `cformat` | `vp format` |
+| `ccheck`  | `vp check`  |
+| `ctest`   | `vp test`   |
+
+Run them with `vp run <task>`, such as `vp run cpack`, or shorthand `vpr cpack`. They can also be used in `package.json` scripts while retaining Vite+ task caching.
+
+### Staged files
+
+Staged-file checks keep automatic fixes close to the commit workflow, so only code that is about to be committed is processed.
+
+All categories run `vp check --fix` for staged files. Run `vp config` to install Vite+'s commit hook.
 
 ## License
 
-[MIT](./LICENSE) License © 2026-PRESENT Liang
+[MIT](./LICENSE) License © 2026-PRESENT Liang & Contributors

package/dist/constants-D9DskZO3.d.mts

@@ -0,0 +1,5 @@
+//#region src/oxlint-plugin/constants.d.ts
+declare const configNames: readonly ["base", "cli", "lib", "website"];
+type ConfigName = (typeof configNames)[number];
+//#endregion
+export { ConfigName as t };

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { c as writeRuntimeInfo } from "./info-CHtwxjhy.mjs";
 import { defineConfig, mergeConfig } from "vite-plus";
 //#region src/base/fmt.ts
 const fmtBase = {
@@ -53,7 +54,10 @@ const componentOverride = {
 };
 //#endregion
 //#region src/base/lint.ts
-const suspicious = { "no-shadow": "off" };
+const suspicious = {
+	"no-shadow": "off",
+	"typescript/no-unsafe-type-assertion": "off"
+};
 const nursery = {
 	"no-undef": "off",
 	"import/named": "off",
@@ -65,6 +69,7 @@ const style = {
 	"typescript/consistent-indexed-object-style": ["warn", "record"],
 	"eslint/func-names": ["warn", "never"],
 	"id-length": ["warn", { checkGeneric: false }],
+	"typescript/method-signature-style": ["warn", "property"],
 	"unicorn/prefer-ternary": ["warn", "only-single-line"],
 	"import/exports-last": "off",
 	"func-style": "off",
@@ -86,7 +91,8 @@ const style = {
 	"import/no-nodejs-modules": "off",
 	"import/prefer-default-export": "off",
 	"prefer-await-to-then": "off",
-	"unicorn/no-null": "off"
+	"unicorn/no-null": "off",
+	"eslint/prefer-named-capture-group": "off"
 };
 const restriction = {
 	"oxc/bad-bitwise-operator": "error",
@@ -211,6 +217,10 @@ const lintBase = {
 		restriction: "off",
 		pedantic: "off"
 	},
+	jsPlugins: [{
+		name: "liangmi",
+		specifier: "@liangmi/vp-config/oxlint-plugin"
+	}],
 	plugins: [
 		"eslint",
 		"oxc",
@@ -225,7 +235,11 @@ const lintBase = {
 		...restriction,
 		...pedantic,
 		...style,
-		"typescript/no-unsafe-type-assertion": "off"
+		"liangmi/no-orphan-vite-config": "error",
+		"liangmi/no-useless-vp-preset-imports": "error",
+		"liangmi/use-preset-vp-config": "error",
+		"liangmi/load-proper-vp-config-category": "error",
+		"liangmi/no-mixed-project": "error"
 	},
 	options: {
 		typeAware: true,
@@ -240,6 +254,24 @@ const lintBase = {
 				node: true,
 				vitest: true
 			},
+			plugins: ["vitest"],
+			rules: {
+				"vitest/consistent-test-filename": ["warn", { pattern: ".*.test.ts$" }],
+				"vitest/consistent-test-it": ["warn", {
+					fn: "it",
+					withinDescribe: "it"
+				}],
+				"vitest/no-hooks": "off",
+				"vitest/require-top-level-describe": "off",
+				"vitest/prefer-strict-boolean-matchers": "off",
+				"vitest/max-expects": "off",
+				"vitest/prefer-expect-assertions": "off",
+				"vitest/prefer-importing-vitest-globals": "off",
+				"vitest/no-importing-vitest-globals": "off",
+				"vitest/no-large-snapshots": "off",
+				"vitest/no-restricted-matchers": "off",
+				"vitest/no-restricted-vi-methods": "off"
+			},
 			files: ["*.test.ts", "*.spec.ts"]
 		},
 		{
@@ -261,42 +293,79 @@ const lintBase = {
 	]
 };
 //#endregion
+//#region src/base/run.ts
+const lintInput = ["!node_modules/.vp-config/info.json", "index.html"];
+const runBase = {
+	tasks: {
+		cbuild: "vp build",
+		ccheck: {
+			command: "vp check",
+			input: lintInput
+		},
+		cfmt: "vp fmt",
+		cformat: "vp format",
+		clint: {
+			command: "vp lint",
+			input: lintInput
+		},
+		cpack: "vp pack",
+		ctest: "vp test"
+	},
+	cache: {
+		scripts: false,
+		tasks: true
+	}
+};
+//#endregion
+//#region src/base/staged.ts
+const stagedBase = { "*": "vp check --fix" };
+//#endregion
 //#region src/base/index.ts
 const baseConfig = {
 	fmt: fmtBase,
-	lint: lintBase
+	lint: lintBase,
+	run: runBase,
+	staged: stagedBase
 };
 //#endregion
 //#region src/website/fmt.ts
 const fmtWebsite = {
+	...fmtBase,
 	jsxSingleQuote: true,
 	embeddedLanguageFormatting: "auto",
-	sortTailwindcss: false,
-	...fmtBase
+	sortTailwindcss: false
 };
 //#endregion
 //#region src/cli/index.ts
 const cliConfig = {
 	fmt: fmtWebsite,
-	lint: mergeConfig(lintBase, mergeConfig(lintBase, componentOverride))
+	lint: mergeConfig(lintBase, mergeConfig(cliOverride, componentOverride)),
+	pack: {
+		dts: false,
+		minify: true,
+		platform: "node",
+		nodeProtocol: "strip"
+	},
+	run: runBase,
+	staged: stagedBase
 };
 //#endregion
 //#region src/entry.ts
-function createConfigEntry(presetConfig) {
-	const entry = ((config) => defineMergedConfig(presetConfig, config));
-	const only = (parts, ...args) => defineMergedConfig(pickPresetConfig(presetConfig, parts), ...args);
-	const exclude = (parts, ...args) => defineMergedConfig(omitPresetConfig(presetConfig, parts), ...args);
+function createConfigEntry(presetConfig, category) {
+	const entry = ((config) => defineMergedConfig(presetConfig, config, category));
+	const only = (parts, ...args) => defineMergedConfig(pickPresetConfig(presetConfig, parts), args[0], category);
+	const exclude = (parts, ...args) => defineMergedConfig(omitPresetConfig(presetConfig, parts), args[0], category);
 	return Object.assign(entry, {
 		only,
 		exclude
 	});
 }
-function defineMergedConfig(presetConfig, config) {
+function defineMergedConfig(presetConfig, config, category) {
 	if (typeof config === "function") return defineConfig(async (env) => {
-		return mergePresetConfig(presetConfig, await config(env));
+		return trackRuntimeInfo(mergePresetConfig(presetConfig, await config(env)), category);
 	});
-	if (config instanceof Promise) return defineConfig(config.then((userConfig) => mergePresetConfig(presetConfig, userConfig)));
-	return defineConfig(mergePresetConfig(presetConfig, config));
+	if (config instanceof Promise) return defineConfig(config.then((userConfig) => trackRuntimeInfo(mergePresetConfig(presetConfig, userConfig), category)));
+	return defineConfig(trackRuntimeInfo(mergePresetConfig(presetConfig, config), category));
 }
 function pickPresetConfig(presetConfig, parts) {
 	return Object.fromEntries(parts.map((part) => [part, presetConfig[part]]));
@@ -314,6 +383,13 @@ function mergePresetConfig(presetConfig, userConfig) {
 	if (presetConfig.staged) config.staged = mergeStagedConfig(presetConfig.staged, userConfig.staged);
 	return config;
 }
+function trackRuntimeInfo(config, category) {
+	writeRuntimeInfo({
+		category,
+		config
+	});
+	return config;
+}
 function mergeLintConfig(presetLint, userLint) {
 	return mergeConfig(presetLint, userLint ?? {});
 }
@@ -333,7 +409,14 @@ function isStagedObjectConfig(config) {
 //#region src/lib/index.ts
 const libConfig = {
 	fmt: fmtBase,
-	lint: mergeConfig(lintBase, {})
+	lint: mergeConfig(lintBase, {}),
+	pack: {
+		fixedExtension: true,
+		exports: true,
+		dts: { tsgo: true }
+	},
+	run: runBase,
+	staged: stagedBase
 };
 //#endregion
 //#region src/website/index.ts
@@ -349,13 +432,15 @@ const websiteConfig = {
 			"prefer-blob-reading-methods": "warn",
 			"import/no-unassigned-import": ["error", { allow: ["**/*.css"] }]
 		}
-	})
+	}),
+	run: runBase,
+	staged: stagedBase
 };
 //#endregion
 //#region src/index.ts
-const base = createConfigEntry(baseConfig);
-const cli = createConfigEntry(cliConfig);
-const lib = createConfigEntry(libConfig);
-const website = createConfigEntry(websiteConfig);
+const base = createConfigEntry(baseConfig, "base");
+const cli = createConfigEntry(cliConfig, "cli");
+const lib = createConfigEntry(libConfig, "lib");
+const website = createConfigEntry(websiteConfig, "website");
 //#endregion
 export { base, cli, lib, website };

package/dist/info-CHtwxjhy.mjs

@@ -0,0 +1,306 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, normalize } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/oxlint-plugin/constants.ts
+const packageName = "@liangmi/vp-config";
+const pluginName = "liangmi";
+const infoDirectoryName = ".vp-config";
+const infoFileName = "info.json";
+const projectConfigNames = [
+	"cli",
+	"lib",
+	"website"
+];
+const rootConfigNames = ["base"];
+const configNames = [...rootConfigNames, ...projectConfigNames];
+const viteConfigNames = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.cts",
+	"vite.config.js",
+	"vite.config.mjs",
+	"vite.config.cjs"
+];
+function isVpConfigEntrySpecifier(specifier) {
+	return specifier === "@liangmi/vp-config" || /(?:^|[\\/])src[\\/]index\.ts$/u.test(specifier) || specifier.endsWith("/src/index.ts");
+}
+//#endregion
+//#region src/oxlint-plugin/info.ts
+function getInfoPath(configDirectory) {
+	return join(configDirectory, "node_modules", infoDirectoryName, infoFileName);
+}
+function readRuntimeInfo(configDirectory) {
+	const infoPath = getInfoPath(configDirectory);
+	if (!existsSync(infoPath)) return;
+	try {
+		const info = JSON.parse(readFileSync(infoPath, "utf8"));
+		return isRuntimeInfo(info) ? info : void 0;
+	} catch {
+		return;
+	}
+}
+function writeRuntimeInfo(input) {
+	const { stack } = /* @__PURE__ */ new Error("Find vite config caller");
+	if (!shouldWriteRuntimeInfo(stack)) return;
+	const configFile = findConfigFileFromStack(stack) ?? findCwdConfigFile();
+	if (!configFile) return;
+	writeRuntimeInfoFile(configFile, input);
+}
+function ensureRuntimeInfo(configFile) {
+	const configDirectory = dirname(configFile);
+	if (!hasConfigPackageJson(configFile)) return;
+	loadRuntimeInfo(configFile);
+	return readRuntimeInfo(configDirectory);
+}
+function cleanupRuntimeInfo(configDirectory) {
+	const info = readRuntimeInfo(configDirectory);
+	const nodeModulesDirectory = join(configDirectory, "node_modules");
+	rmSync(getInfoPath(configDirectory), { force: true });
+	rmSync(join(nodeModulesDirectory, infoDirectoryName), {
+		recursive: true,
+		force: true
+	});
+	if (info?.cleanup.createdNodeModules) rmSync(nodeModulesDirectory, {
+		recursive: true,
+		force: true
+	});
+}
+function writeRuntimeInfoFile(configFile, input) {
+	if (!hasConfigPackageJson(configFile)) return;
+	const configDirectory = dirname(configFile);
+	const createdNodeModules = !existsSync(join(configDirectory, "node_modules"));
+	const infoPath = getInfoPath(configDirectory);
+	rmSync(infoPath, { force: true });
+	mkdirSync(dirname(infoPath), { recursive: true });
+	writeFileSync(infoPath, `${JSON.stringify(createRuntimeInfo(configFile, input, createdNodeModules), null, 2)}\n`);
+}
+function shouldWriteRuntimeInfo(stack) {
+	return hasOxlintEntryStack(stack) || hasVitePlusResolveStack(stack);
+}
+function hasOxlintEntryStack(stack) {
+	return Boolean(stack && /node_modules[\\/](?:\.pnpm[\\/]oxlint@[^\\/]+[\\/]node_modules[\\/])?oxlint[\\/]dist[\\/]/u.test(stack));
+}
+function hasVitePlusResolveStack(stack) {
+	return Boolean(stack && /node_modules[\\/]vite-plus[\\/]dist[\\/]resolve-vite-config(?:-[^\\/]+)?\.js/u.test(stack));
+}
+function loadRuntimeInfo(configFile) {
+	const input = readRuntimeConfigInput(configFile);
+	if (input) writeRuntimeInfoFile(configFile, input);
+}
+function createRuntimeInfo(configFile, input, createdNodeModules) {
+	const configDirectory = dirname(configFile);
+	const configKeys = Object.keys(input.config);
+	const hasPack = configKeys.includes("pack");
+	const hasViteConfigFields = configKeys.some(isViteConfigField);
+	return {
+		version: 1,
+		configFile,
+		configDirectory,
+		category: input.category,
+		configKeys,
+		project: {
+			hasViteConfigFields,
+			hasPack
+		},
+		cleanup: { createdNodeModules }
+	};
+}
+const vitePlusConfigKeys = new Set([
+	"create",
+	"fmt",
+	"lint",
+	"pack",
+	"run",
+	"staged",
+	"test"
+]);
+function isViteConfigField(key) {
+	return !vitePlusConfigKeys.has(key);
+}
+function findConfigFileFromStack(stack) {
+	if (!stack) return;
+	for (const rawLine of stack.split("\n")) {
+		const path = normalizeStackPath(rawLine);
+		const configPath = path ? resolveBundledConfigPath(path) : void 0;
+		if (configPath && viteConfigNames.includes(getPathBasename(configPath))) return configPath;
+	}
+}
+function getPathBasename(path) {
+	return path.split(/[\\/]/u).at(-1) ?? path;
+}
+function normalizeStackPath(line) {
+	const fileUrlMatch = /file:\/\/\/.*?vite\.config\.[cm]?[jt]s/u.exec(line);
+	if (fileUrlMatch) return fileURLToPath(fileUrlMatch[0]);
+	const absolutePathMatch = /((?:[a-zA-Z]:[\\/]|\/)[^:)]+vite\.config\.[cm]?[jt]s)/u.exec(line);
+	return absolutePathMatch ? normalize(absolutePathMatch[1]) : void 0;
+}
+function resolveBundledConfigPath(path) {
+	const bundledConfigMatch = /^(.*)([\\/])node_modules[\\/]\.vite-temp[\\/](vite\.config\.[cm]?[jt]s)$/u.exec(path);
+	return bundledConfigMatch ? `${bundledConfigMatch[1]}${bundledConfigMatch[2]}${bundledConfigMatch[3]}` : path;
+}
+function readRuntimeConfigInput(configFile) {
+	try {
+		return parseRuntimeConfigInput(readFileSync(configFile, "utf8"));
+	} catch {
+		return;
+	}
+}
+function parseRuntimeConfigInput(source) {
+	const imports = getConfigImports(source);
+	for (const [localName, category] of imports.named) {
+		const input = findConfigCallInput(source, localName, category);
+		if (input) return input;
+	}
+	for (const namespace of imports.namespaces) for (const category of configNames) {
+		const input = findConfigCallInput(source, `${namespace}.${category}`, category);
+		if (input) return input;
+	}
+}
+function getConfigImports(source) {
+	const named = /* @__PURE__ */ new Map();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/import\s*\{(?<imports>[^}]+)\}\s*from\s*['"](?<specifier>[^'"]+)['"]/gu)) {
+		if (!isConfigEntrySpecifier(match.groups?.specifier)) continue;
+		for (const specifier of splitSimpleList(match.groups?.imports ?? "")) {
+			const [importedName, localName] = specifier.split(/\s+as\s+/u).map((part) => part.trim());
+			const category = toConfigName(importedName);
+			if (category) named.set(localName || importedName, category);
+		}
+	}
+	for (const match of source.matchAll(/import\s*\*\s*as\s*(?<localName>[$A-Z_a-z][$\w]*)\s*from\s*['"](?<specifier>[^'"]+)['"]/gu)) if (isConfigEntrySpecifier(match.groups?.specifier) && match.groups?.localName) namespaces.add(match.groups.localName);
+	for (const match of source.matchAll(/const\s*\{(?<imports>[^}]+)\}\s*=\s*require\(\s*['"](?<specifier>[^'"]+)['"]\s*\)/gu)) {
+		if (!isConfigEntrySpecifier(match.groups?.specifier)) continue;
+		for (const specifier of splitSimpleList(match.groups?.imports ?? "")) {
+			const [importedName, localName] = specifier.split(/\s*:\s*/u).map((part) => part.trim());
+			const category = toConfigName(importedName);
+			if (category) named.set(localName || importedName, category);
+		}
+	}
+	return {
+		named,
+		namespaces
+	};
+}
+function findConfigCallInput(source, callee, category) {
+	const callPattern = new RegExp(`(^|[^$\\w])${callee.split(".").map((part) => escapeRegExp(part)).join(String.raw`\s*\.\s*`)}\\s*(?:\\.\\s*(?<method>only|exclude)\\s*)?\\(`, "gu");
+	for (const match of source.matchAll(callPattern)) {
+		const argument = readCallArgument(source, match.index + match[0].lastIndexOf("("), match.groups?.method ? 1 : 0);
+		const configKeys = argument ? readObjectKeys(argument) : [];
+		if (configKeys.length > 0 || argument?.trim() === "{}") return {
+			category,
+			config: Object.fromEntries(configKeys.map((key) => [key, true]))
+		};
+	}
+}
+function readCallArgument(source, openParenIndex, argumentIndex) {
+	const closeParenIndex = findClosingDelimiter(source, openParenIndex, "(", ")");
+	if (closeParenIndex === void 0) return;
+	return splitTopLevel(source.slice(openParenIndex + 1, closeParenIndex))[argumentIndex];
+}
+function readObjectKeys(source) {
+	const objectStart = source.search(/\S/u);
+	if (objectStart === -1 || source[objectStart] !== "{") return [];
+	const objectEnd = findClosingDelimiter(source, objectStart, "{", "}");
+	if (objectEnd === void 0) return [];
+	return splitTopLevel(source.slice(objectStart + 1, objectEnd)).flatMap(readPropertyKey);
+}
+function readPropertyKey(source) {
+	const property = source.trim();
+	if (!property || property.startsWith("...") || property.startsWith("[")) return [];
+	const quotedKeyMatch = /^['"](?<key>[^'"]+)['"]\s*[:(]/u.exec(property);
+	if (quotedKeyMatch?.groups?.key) return [quotedKeyMatch.groups.key];
+	const identifierKeyMatch = /^(?:async\s+|get\s+|set\s+)?(?<key>[$A-Z_a-z][$\w]*)\s*(?::|\(|$)/u.exec(property);
+	return identifierKeyMatch?.groups?.key ? [identifierKeyMatch.groups.key] : [];
+}
+function splitTopLevel(source) {
+	const parts = [];
+	let start = 0;
+	let depth = 0;
+	for (let index = 0; index < source.length; index += 1) {
+		const skippedIndex = skipSyntax(source, index);
+		if (skippedIndex !== index) {
+			index = skippedIndex;
+			continue;
+		}
+		const char = source[index];
+		if (char === "(" || char === "[" || char === "{") depth += 1;
+		else if (char === ")" || char === "]" || char === "}") depth -= 1;
+		else if (char === "," && depth === 0) {
+			parts.push(source.slice(start, index).trim());
+			start = index + 1;
+		}
+	}
+	parts.push(source.slice(start).trim());
+	return parts.filter(Boolean);
+}
+function findClosingDelimiter(source, openIndex, openDelimiter, closeDelimiter) {
+	let depth = 0;
+	for (let index = openIndex; index < source.length; index += 1) {
+		const skippedIndex = skipSyntax(source, index);
+		if (skippedIndex !== index) {
+			index = skippedIndex;
+			continue;
+		}
+		if (source[index] === openDelimiter) depth += 1;
+		else if (source[index] === closeDelimiter) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+}
+function skipSyntax(source, index) {
+	const char = source[index];
+	const nextChar = source[index + 1];
+	if (char === "\"" || char === "'" || char === "`") return skipString(source, index, char);
+	if (char === "/" && nextChar === "/") return skipLineComment(source, index);
+	if (char === "/" && nextChar === "*") return skipBlockComment(source, index);
+	return index;
+}
+function skipString(source, start, quote) {
+	for (let index = start + 1; index < source.length; index += 1) if (source[index] === "\\") index += 1;
+	else if (source[index] === quote) return index;
+	return source.length - 1;
+}
+function skipLineComment(source, start) {
+	const end = source.indexOf("\n", start + 2);
+	return end === -1 ? source.length - 1 : end;
+}
+function skipBlockComment(source, start) {
+	const end = source.indexOf("*/", start + 2);
+	return end === -1 ? source.length - 1 : end + 1;
+}
+function splitSimpleList(source) {
+	return source.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function isConfigEntrySpecifier(specifier) {
+	return specifier ? isVpConfigEntrySpecifier(specifier) : false;
+}
+function toConfigName(name) {
+	return configNames.includes(name) ? name : void 0;
+}
+function escapeRegExp(value) {
+	return value.replaceAll(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`);
+}
+function findCwdConfigFile() {
+	for (const configName of viteConfigNames) {
+		const configFile = join(process.cwd(), configName);
+		if (existsSync(configFile)) return configFile;
+	}
+}
+function hasConfigPackageJson(configFile) {
+	return existsSync(join(dirname(configFile), "package.json"));
+}
+function isRuntimeInfo(value) {
+	return typeof value === "object" && value !== null && "version" in value && value.version === 1 && "project" in value && typeof value.project === "object" && value.project !== null;
+}
+function isWebsiteProject(info) {
+	return existsSync(join(info.configDirectory, "index.html")) || info.project.hasViteConfigFields;
+}
+function isLibProject(info) {
+	return info.project.hasPack;
+}
+function isProject(info) {
+	return isWebsiteProject(info) || isLibProject(info);
+}
+//#endregion
+export { isProject as a, writeRuntimeInfo as c, projectConfigNames as d, rootConfigNames as f, isLibProject as i, packageName as l, ensureRuntimeInfo as n, isWebsiteProject as o, viteConfigNames as p, getInfoPath as r, readRuntimeInfo as s, cleanupRuntimeInfo as t, pluginName as u };

package/dist/oxlint-plugin/index.d.mts

@@ -0,0 +1,34 @@
+import { t as ConfigName } from "../constants-D9DskZO3.mjs";
+
+//#region src/oxlint-plugin/project.d.ts
+declare function getAllowedConfigNames(filename: string): readonly ConfigName[];
+declare function isVpConfigImportAllowed(filename: string, importedNames: readonly string[]): boolean;
+//#endregion
+//#region src/oxlint-plugin/info.d.ts
+interface VpConfigRuntimeInfo {
+  version: 1;
+  configFile: string;
+  configDirectory: string;
+  category?: ConfigName;
+  configKeys: string[];
+  project: {
+    hasViteConfigFields: boolean;
+    hasPack: boolean;
+  };
+  cleanup: {
+    createdNodeModules: boolean;
+  };
+}
+interface RuntimeConfigInput {
+  category?: ConfigName;
+  config: Record<string, unknown>;
+}
+declare function getInfoPath(configDirectory: string): string;
+declare function readRuntimeInfo(configDirectory: string): VpConfigRuntimeInfo | undefined;
+declare function writeRuntimeInfo(input: RuntimeConfigInput): void;
+declare function cleanupRuntimeInfo(configDirectory: string): void;
+//#endregion
+//#region src/oxlint-plugin/index.d.ts
+declare const _default: import("@oxlint/plugins").Plugin;
+//#endregion
+export { cleanupRuntimeInfo, _default as default, getAllowedConfigNames, getInfoPath, isVpConfigImportAllowed, readRuntimeInfo, writeRuntimeInfo };

package/dist/oxlint-plugin/index.mjs

@@ -0,0 +1,161 @@
+import { a as isProject, c as writeRuntimeInfo, d as projectConfigNames, f as rootConfigNames, i as isLibProject, l as packageName, n as ensureRuntimeInfo, o as isWebsiteProject, p as viteConfigNames, r as getInfoPath, s as readRuntimeInfo, t as cleanupRuntimeInfo, u as pluginName } from "../info-CHtwxjhy.mjs";
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { definePlugin, defineRule } from "@oxlint/plugins";
+//#region src/oxlint-plugin/ast.ts
+function isVpConfigSpecifier(specifier) {
+	return specifier === packageName;
+}
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+//#endregion
+//#region src/oxlint-plugin/project.ts
+function getAllowedConfigNames(filename) {
+	if (!isViteConfigFile(filename)) return [];
+	const info = readRuntimeInfo(dirname(filename));
+	return (info ? isProject(info) : isStaticWebsiteProjectDirectory(dirname(filename))) ? projectConfigNames : rootConfigNames;
+}
+function isVpConfigImportAllowed(filename, importedNames) {
+	const allowedNames = getAllowedConfigNames(filename);
+	const allowedNameSet = new Set(allowedNames);
+	return allowedNames.length > 0 && importedNames.length > 0 && importedNames.every((name) => allowedNameSet.has(name));
+}
+function isViteConfigFile(filename) {
+	return viteConfigNames.includes(basename(filename));
+}
+function hasPackageJson(directory) {
+	return existsSync(join(directory, "package.json"));
+}
+function isStaticWebsiteProjectDirectory(directory) {
+	return existsSync(join(directory, "index.html"));
+}
+//#endregion
+//#region src/oxlint-plugin/rules.ts
+function canUseRuntimeInfo(filename) {
+	return isViteConfigFile(filename) && hasPackageJson(dirname(filename));
+}
+const rules = {
+	"no-orphan-vite-config": defineRule({
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Require vite.config files to live next to package.json.",
+				recommended: true
+			},
+			messages: { orphan: "Keep vite.config.ts next to package.json." }
+		},
+		create(context) {
+			return { Program(node) {
+				if (isViteConfigFile(context.filename) && !hasPackageJson(dirname(context.filename))) context.report({
+					node,
+					messageId: "orphan"
+				});
+			} };
+		}
+	}),
+	"no-useless-vp-preset-imports": defineRule({
+		meta: {
+			type: "problem",
+			docs: {
+				description: `Disallow importing ${packageName} outside vite.config files.`,
+				recommended: true
+			},
+			messages: { outsideConfig: `Import ${packageName} only from vite.config.ts.` }
+		},
+		create(context) {
+			const reportModuleReference = (node, specifier) => {
+				if (!isVpConfigSpecifier(specifier) || isViteConfigFile(context.filename)) return;
+				context.report({
+					node,
+					messageId: "outsideConfig"
+				});
+			};
+			return {
+				ImportDeclaration(node) {
+					reportModuleReference(node.source, node.source.value);
+				},
+				ExportAllDeclaration(node) {
+					reportModuleReference(node.source, node.source.value);
+				},
+				ExportNamedDeclaration(node) {
+					if (node.source) reportModuleReference(node.source, node.source.value);
+				},
+				ImportExpression(node) {
+					if (isStringLiteral(node.source)) reportModuleReference(node.source, node.source.value);
+				}
+			};
+		}
+	}),
+	"use-preset-vp-config": defineRule({
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Require vite.config.ts to be loaded through @liangmi/vp-config.",
+				recommended: true
+			},
+			messages: { missingRuntimeInfo: `Load vite.config.ts through ${packageName} so lint rules can inspect runtime config.` }
+		},
+		create(context) {
+			return { Program(node) {
+				if (!canUseRuntimeInfo(context.filename)) return;
+				if (!ensureRuntimeInfo(context.filename)) context.report({
+					node,
+					messageId: "missingRuntimeInfo"
+				});
+			} };
+		}
+	}),
+	"load-proper-vp-config-category": defineRule({
+		meta: {
+			type: "problem",
+			docs: {
+				description: `Load ${packageName} with a category that matches the package role.`,
+				recommended: true
+			},
+			messages: { wrongCategory: `Use {{expected}} from ${packageName} in this vite.config.ts.` }
+		},
+		create(context) {
+			return { Program(node) {
+				if (!canUseRuntimeInfo(context.filename)) return;
+				const info = ensureRuntimeInfo(context.filename);
+				if (!info?.category) return;
+				const allowed = isProject(info) ? projectConfigNames : rootConfigNames;
+				if (allowed.includes(info.category)) return;
+				context.report({
+					node,
+					messageId: "wrongCategory",
+					data: { expected: allowed.map((name) => `{ ${name} }`).join(" or ") }
+				});
+			} };
+		}
+	}),
+	"no-mixed-project": defineRule({
+		meta: {
+			type: "problem",
+			docs: {
+				description: "Disallow a vite config that is both website and library project.",
+				recommended: true
+			},
+			messages: { mixed: "Do not mix website and library project signals in one vite.config.ts." }
+		},
+		create(context) {
+			return { Program(node) {
+				if (!canUseRuntimeInfo(context.filename)) return;
+				const info = ensureRuntimeInfo(context.filename);
+				if (info && isWebsiteProject(info) && isLibProject(info)) context.report({
+					node,
+					messageId: "mixed"
+				});
+			} };
+		}
+	})
+};
+//#endregion
+//#region src/oxlint-plugin/index.ts
+var oxlint_plugin_default = definePlugin({
+	meta: { name: pluginName },
+	rules
+});
+//#endregion
+export { cleanupRuntimeInfo, oxlint_plugin_default as default, getAllowedConfigNames, getInfoPath, isVpConfigImportAllowed, readRuntimeInfo, writeRuntimeInfo };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@liangmi/vp-config",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Liang's JavaScript development toolchain config with Vite+.",
   "homepage": "https://github.com/liangmiQwQ/vp-config#readme",
   "bugs": {
@@ -18,28 +18,28 @@
   "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./oxlint-plugin": "./dist/oxlint-plugin/index.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
-    "@types/node": "^25.6.2",
-    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "@types/node": "^26.0.0",
+    "@typescript/native-preview": "7.0.0-dev.20260620.1",
     "bumpp": "^11.1.0",
-    "tinyglobby": "^0.2.17",
     "typescript": "^6.0.3",
-    "vite-plus": "^0.1.24",
-    "yaml": "^2.9.0"
+    "vite-plus": "^0.2.1"
   },
   "peerDependencies": {
-    "vite-plus": "^0.1.22"
+    "@oxlint/plugins": "1.61.0",
+    "vite-plus": ">=0.2.0"
   },
   "scripts": {
-    "build": "vp pack",
-    "check": "vp check",
+    "build": "vp run cpack",
+    "check": "vp run cpack && vp run ccheck",
     "dev": "vp pack --watch",
     "release": "bumpp",
-    "test": "vp test"
+    "test": "vp run ctest"
   }
 }