@vizejs/vite-plugin 0.424.10 → 0.426.0

package/dist/plugin-CewswkDY.mjs

@@ -0,0 +1,2 @@
+import { t as vize } from "./plugin-BSxbzkGl.mjs";
+export { vize };

package/dist/runner-DvShtC55.mjs

@@ -0,0 +1,202 @@
+import { i as resolveConfigExport, r as loadConfig } from "./config-PP6EAmWc.mjs";
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { glob } from "tinyglobby";
+import { spawn, spawnSync } from "node:child_process";
+import os from "node:os";
+import { rm, writeFile } from "node:fs/promises";
+//#region src/vite-plus/types.ts
+const sourceConfigKey = Symbol.for("@vizejs/vite-plugin/vite-plus/source");
+const taskConfigKey = Symbol.for("@vizejs/vite-plugin/vite-plus");
+//#endregion
+//#region src/vite-plus/runtime.ts
+function resolveVitePlus() {
+	const require = createRequire(path.resolve("package.json"));
+	let packageFile;
+	try {
+		packageFile = require.resolve("vite-plus/package.json");
+	} catch {
+		throw new Error("defineConfig requires vite-plus installed in this project. Install your preferred version first.");
+	}
+	const manifest = JSON.parse(readFileSync(packageFile, "utf8"));
+	return {
+		require,
+		binary: path.resolve(path.dirname(packageFile), manifest.bin.vp)
+	};
+}
+const catalogs = /* @__PURE__ */ new Map();
+/** Only disable rules supported by the consumer's bundled Oxlint. */
+function availableVueRules() {
+	const { binary } = resolveVitePlus();
+	const cached = catalogs.get(binary);
+	if (cached) return cached;
+	const directory = mkdtempSync(path.join(os.tmpdir(), "vize-oxlint-rules-"));
+	try {
+		writeFileSync(path.join(directory, "package.json"), "{\"name\":\"vize-rule-catalog\",\"private\":true}");
+		const result = spawnSync(process.execPath, [
+			binary,
+			"lint",
+			"--rules",
+			"--format=json"
+		], {
+			cwd: directory,
+			encoding: "utf8",
+			timeout: 1e4,
+			maxBuffer: 4 * 1024 * 1024
+		});
+		if (result.error || result.status !== 0) throw new Error(`Cannot read installed Vite+ lint rules: ${result.error?.message ?? result.stderr}`);
+		const rules = JSON.parse(result.stdout);
+		if (!Array.isArray(rules)) throw new Error("Installed Vite+ returned an invalid lint rule catalog");
+		const available = new Set(rules.filter((rule) => rule.scope === "vue").map((rule) => rule.value));
+		catalogs.set(binary, available);
+		return available;
+	} finally {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/vite-plus/runner.ts
+/** Run every selected checker, even when an earlier tool reports diagnostics. */
+async function runTools(task, args, metadata, vp, native, execute) {
+	const { options } = metadata;
+	const lint = task === "check" || task === "lint" || task === "lint:fix";
+	const fmt = task === "check" || task === "fmt" || task === "fmt:check";
+	const fix = task === "lint:fix" || args.includes("--fix");
+	const formatCheck = task === "fmt:check" || task === "check" && !fix || args.includes("--check");
+	if (task === "check" && args.some((arg) => arg.startsWith("-") && arg !== "--fix")) throw new Error("Vize check tasks accept paths and --fix. Put native tool options in defineConfig().");
+	let status = 0;
+	async function run(binary, argv) {
+		const code = await execute(process.execPath, [binary, ...argv]);
+		if (code >= 128) throw Object.assign(/* @__PURE__ */ new Error("Vize task interrupted"), { exitCode: code });
+		status = Math.max(status, code);
+	}
+	async function vize(command, argv) {
+		const code = await runNative(command, argv, metadata, native, execute);
+		if (code >= 128) throw Object.assign(/* @__PURE__ */ new Error("Vize task interrupted"), { exitCode: code });
+		status = Math.max(status, code);
+	}
+	if (options.check !== false && (task === "check" || task === "typecheck" || lint && metadata.lintTypecheck)) await vize("check", args.filter((arg) => arg !== "--fix"));
+	if (lint) {
+		const lintArgs = fix && !args.includes("--fix") ? ["--fix", ...args] : args;
+		if (options.lint !== false) await vize("lint", lintArgs);
+		await run(vp, ["lint", ...lintArgs]);
+	}
+	if (fmt) {
+		const patterns = args.filter((arg) => ![
+			"--check",
+			"--write",
+			"-w",
+			"--fix"
+		].includes(arg));
+		if (patterns.some((arg) => arg.startsWith("-"))) throw new Error("Vize fmt tasks accept paths and --check/--write. Put native formatter options in defineConfig({ fmt: { vize: ... } }).");
+		if (options.fmt !== false) {
+			const vue = (await glob(patterns.length ? patterns : ["**/*.vue"], {
+				expandDirectories: true,
+				ignore: [
+					"**/node_modules/**",
+					"**/.git/**",
+					"**/.vize/**"
+				]
+			})).filter((file) => file.endsWith(".vue"));
+			if (vue.length) await vize("fmt", [formatCheck ? "--check" : "--write", ...vue]);
+		}
+		await run(vp, [
+			"fmt",
+			formatCheck ? "--check" : "--write",
+			...patterns
+		]);
+	}
+	return status;
+}
+async function runTask(argv) {
+	const [task, ...rest] = argv;
+	const args = rest[0] === "--" ? rest.slice(1) : rest;
+	if (task === "editor:setup") {
+		const { setupEditor } = await import("./editor-D3tfVb0Z.mjs");
+		await setupEditor();
+		return 0;
+	}
+	const { require, binary: vp } = resolveVitePlus();
+	if ([
+		"build",
+		"dev",
+		"preview",
+		"test",
+		"pack"
+	].includes(task)) return execute(process.execPath, [
+		vp,
+		task,
+		...args
+	]);
+	if (![
+		"check",
+		"typecheck",
+		"lint",
+		"lint:fix",
+		"fmt",
+		"fmt:check"
+	].includes(task)) throw new Error(`Unknown Vize task: ${task}`);
+	const { loadConfigFromFile } = require("vite-plus");
+	const metadata = ((await loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}))?.config)?.[taskConfigKey];
+	if (!metadata) throw new Error("The current vite.config must use defineConfig from @vizejs/vite-plugin/vite-plus.");
+	return runTools(task, args, metadata, vp, nativeBinary(), execute);
+}
+async function execute(command, args) {
+	return new Promise((resolve) => {
+		const child = spawn(command, args, { stdio: "inherit" });
+		const forwardInt = () => child.kill("SIGINT");
+		const forwardTerm = () => child.kill("SIGTERM");
+		process.on("SIGINT", forwardInt);
+		process.on("SIGTERM", forwardTerm);
+		const cleanup = () => {
+			process.off("SIGINT", forwardInt);
+			process.off("SIGTERM", forwardTerm);
+		};
+		child.once("error", (error) => {
+			cleanup();
+			console.error(error.message);
+			resolve(1);
+		});
+		child.once("exit", (code, signal) => {
+			cleanup();
+			resolve(code ?? (signal === "SIGINT" ? 130 : signal === "SIGTERM" ? 143 : 1));
+		});
+	});
+}
+function nativeBinary() {
+	const require = createRequire(import.meta.url);
+	return path.resolve(path.dirname(require.resolve("vize")), "../bin/vize");
+}
+async function runNative(command, argv, metadata, native = nativeBinary(), spawn = execute) {
+	const env = {
+		mode: "production",
+		command
+	};
+	const config = metadata.config === void 0 ? await loadConfig(process.cwd(), { env }) ?? {} : await resolveConfigExport(metadata.config, env);
+	const file = path.resolve(`.vize-vp-${randomUUID()}.json`);
+	try {
+		await writeFile(file, JSON.stringify(config), {
+			flag: "wx",
+			mode: 384
+		});
+		return await spawn(process.execPath, [
+			native,
+			command,
+			"--config",
+			file,
+			...argv
+		]);
+	} finally {
+		await rm(file, { force: true });
+	}
+}
+//#endregion
+export { sourceConfigKey as a, resolveVitePlus as i, runTask as n, taskConfigKey as o, availableVueRules as r, runNative as t };

package/dist/shared-config-dMxrrTkb.mjs

@@ -0,0 +1,69 @@
+import { i as resolveConfigExport, r as loadConfig } from "./config-PP6EAmWc.mjs";
+//#region src/plugin/shared-config.ts
+function mergeSharedConfig(baseConfig, overrideConfig) {
+	if (!baseConfig) return overrideConfig;
+	if (!overrideConfig) return baseConfig;
+	return {
+		...baseConfig,
+		...overrideConfig,
+		compiler: {
+			...baseConfig.compiler,
+			...overrideConfig.compiler
+		},
+		vite: {
+			...baseConfig.vite,
+			...overrideConfig.vite
+		},
+		linter: {
+			...baseConfig.linter,
+			...overrideConfig.linter
+		},
+		typeChecker: {
+			...baseConfig.typeChecker,
+			...overrideConfig.typeChecker
+		},
+		formatter: {
+			...baseConfig.formatter,
+			...overrideConfig.formatter
+		},
+		languageServer: {
+			...baseConfig.languageServer,
+			...overrideConfig.languageServer
+		},
+		musea: {
+			...baseConfig.musea,
+			...overrideConfig.musea
+		},
+		globalTypes: {
+			...baseConfig.globalTypes,
+			...overrideConfig.globalTypes
+		},
+		entries: [...baseConfig.entries, ...overrideConfig.entries]
+	};
+}
+async function resolveSharedConfig(options, root, env, logger) {
+	let fileConfig = null;
+	if (options.configMode !== false) {
+		const configFile = options.configFile ?? process.env["VIZE_CONFIG_FILE"];
+		try {
+			fileConfig = await loadConfig(root, {
+				mode: options.configMode ?? "root",
+				configFile,
+				env
+			});
+			if (fileConfig) logger.log("Loaded config from vize.config file");
+		} catch (error) {
+			logger.warn(`Failed to load vize config from ${configFile ?? root}:`, error);
+		}
+	}
+	let inlineConfig = null;
+	if (options.config) try {
+		inlineConfig = await resolveConfigExport(options.config, env);
+		logger.log("Loaded inline vize config from plugin options");
+	} catch (error) {
+		logger.warn("Failed to resolve inline vize config:", error);
+	}
+	return mergeSharedConfig(fileConfig, inlineConfig);
+}
+//#endregion
+export { resolveSharedConfig as n, mergeSharedConfig as t };

package/dist/{types-DliFOfUZ.d.mts → types-CtulgM97.d.mts}

@@ -1164,4 +1164,4 @@ interface VizeOptions extends ExperimentalPluginOptions {
   debug?: boolean;
 }
 //#endregion
-export { VizeInspectorLintPlanProvider as a, VizeCompatibilityOptions as c, LoadConfigOptions as d, ResolvedVizeConfig as f, VizeVueFeatures as i, VizeVueVersion as l, VizeConfig as m, CompiledModule as n, VizeInspectorLintPlanRequest as o, UserConfigExport as p, MacroArtifact as r, VizeInspectorOptions as s, VizeOptions as t, ConfigEnv as u };
+export { LinterConfig as _, VizeInspectorLintPlanProvider as a, VizeCompatibilityOptions as c, LoadConfigOptions as d, ResolvedVizeConfig as f, FormatterConfig as g, CompilerConfig as h, VizeVueFeatures as i, VizeVueVersion as l, UserConfigExport as m, CompiledModule as n, VizeInspectorLintPlanRequest as o, UserConfig as p, MacroArtifact as r, VizeInspectorOptions as s, VizeOptions as t, ConfigEnv as u, TypeCheckerConfig as v, VizeConfig as y };

package/dist/vite-plus.d.mts

@@ -0,0 +1,65 @@
+import { _ as LinterConfig, g as FormatterConfig, h as CompilerConfig, m as UserConfigExport, p as UserConfig$1, t as VizeOptions, v as TypeCheckerConfig } from "./types-CtulgM97.mjs";
+import { ConfigEnv, UserConfig, defineConfig as defineConfig$1 } from "vite-plus";
+
+//#region src/vite-plus/types.d.ts
+/** Inherit configuration additions from the consumer's Vite+ version. */
+type VitePlusConfig = Parameters<typeof defineConfig$1>[0];
+type VizeCompilerOptions = Omit<CompilerConfig, "compatibility"> & Omit<VizeOptions, "config">;
+interface VizeLintOptions extends LinterConfig {
+  /** Also run the native typechecker before linting. @default false */
+  typecheck?: boolean;
+}
+interface VizePackOptions {
+  /** Emit Vue and TypeScript declarations after the bundle succeeds. @default true */
+  dts?: boolean;
+  /** Override the native declaration output directory. Defaults to pack.outDir. */
+  declarationDir?: string;
+  /** Emit declaration maps pointing to authored sources. */
+  declarationMap?: boolean;
+  /** Enable compiler and bundle source maps. */
+  sourcemap?: boolean;
+  /** TypeScript project used for declaration generation. */
+  tsconfig?: string;
+}
+type WithPack<T> = T extends (infer Item)[] ? WithPack<Item>[] : T & {
+  vize?: VizePackOptions | false;
+};
+type VizeSharedConfig = UserConfig$1 & {
+  /** Alias of lint.vize; lint.vize takes precedence when both are provided. */lint?: VizeLintOptions | boolean;
+};
+interface VueIntegrationConfig {
+  extends?: VueConfig | VueConfig[];
+  compiler?: VizeCompilerOptions | false;
+  typecheck?: TypeCheckerConfig | boolean;
+  lint?: UserConfig["lint"] & {
+    vize?: VizeLintOptions | boolean;
+  };
+  fmt?: UserConfig["fmt"] & {
+    vize?: FormatterConfig | boolean;
+  };
+  pack?: WithPack<NonNullable<UserConfig["pack"]>>;
+  /** Shared native settings, including scopes, globals and editor settings. */
+  vize?: VizeSharedConfig | UserConfigExport;
+}
+type WithVize<T> = T extends ((...args: infer Args) => infer Result) ? (...args: Args) => WithVize<Result> : T extends Promise<infer Result> ? Promise<WithVize<Result>> : Omit<T, "lint" | "fmt" | "pack"> & VueIntegrationConfig;
+type VueConfig = WithVize<VitePlusConfig>;
+type VueConfigObject = Omit<UserConfig, "lint" | "fmt" | "pack"> & VueIntegrationConfig;
+type VizeTask = "editor:setup" | "check" | "typecheck" | "lint" | "lint:fix" | "fmt" | "fmt:check" | "pack" | "build" | "dev" | "preview" | "test";
+interface VizePlusOptions {
+  /** Compiler plugin options; prefer the compiler config section. */
+  plugin?: Omit<VizeOptions, "config"> | false;
+  check?: boolean;
+  lint?: boolean;
+  fmt?: boolean;
+  /** Disable overlapping Oxlint rules and exclude Vue from Oxfmt. @default true */
+  conflicts?: boolean;
+  /** Rename or disable generated tasks. Existing run.tasks take precedence. */
+  tasks?: false | Partial<Record<VizeTask, string | false>>;
+}
+type VizePlusConfigFactory = (env: ConfigEnv) => Promise<UserConfig>;
+//#endregion
+//#region src/vite-plus.d.ts
+/** Extend the installed Vite+ configuration with the native Vue toolchain. */
+declare function defineConfig(config?: VueConfig, integration?: VizePlusOptions): VizePlusConfigFactory;
+//#endregion
+export { type VitePlusConfig, type VizeCompilerOptions, type VizeLintOptions, type VizePackOptions, type VizePlusConfigFactory, type VizePlusOptions, type VizeTask, type VueConfig, type VueConfigObject, defineConfig, defineConfig as withVize, defineConfig as withVue };