webanvil 0.0.6 → 0.0.8

package/dist/_chunks/config.mjs

@@ -0,0 +1,140 @@
+import { loadConfig } from "c12";
+import { defu } from "defu";
+import { z } from "zod";
+const NODE_PLUGIN_ERROR = "Node builds require plugins created with definePlugin()";
+const definePlugin = (plugin, options) => ({
+	rolldown: () => plugin.rolldown(options),
+	vite: () => plugin.vite(options)
+});
+const isUnpluginAdapter = (plugin) => typeof plugin === "object" && plugin !== null && "rolldown" in plugin && typeof plugin.rolldown === "function" && "vite" in plugin && typeof plugin.vite === "function";
+const isWebAnvilPlugin = (plugin) => Array.isArray(plugin) || typeof plugin === "function" || typeof plugin === "object" && plugin !== null && "name" in plugin || isUnpluginAdapter(plugin);
+const resolveRolldownPlugins = (plugins) => plugins.flatMap((plugin) => {
+	if (!isUnpluginAdapter(plugin)) throw new Error(NODE_PLUGIN_ERROR);
+	return plugin.rolldown();
+});
+const resolveVitePlugins = (plugins) => plugins.map((plugin) => isUnpluginAdapter(plugin) ? plugin.vite() : plugin);
+const copyMappingSchema = z.strictObject({
+	from: z.string().min(1),
+	to: z.string().min(1)
+});
+const legacyPlatformTarget = (target) => (typeof target === "string" ? [target] : target).find((value) => value === "browser" || value === "neutral");
+const assertSyntaxTarget = (target) => {
+	if (target === void 0) return;
+	const legacy = legacyPlatformTarget(target);
+	if (legacy !== void 0) throw new Error(`build.target no longer selects a platform; use build.platform: "${legacy}" instead`);
+};
+const syntaxTargetSchema = z.union([z.string().min(1), z.array(z.string().min(1)).min(1)]).superRefine((target, context) => {
+	const legacy = legacyPlatformTarget(target);
+	if (legacy !== void 0) context.addIssue({
+		code: "custom",
+		message: `build.target no longer selects a platform; use build.platform: "${legacy}" instead`
+	});
+});
+const nativeConfigSchema = () => z.custom((value) => typeof value === "object" && value !== null && !Array.isArray(value), "Expected a configuration object");
+const buildConfigSchema = z.strictObject({
+	bundle: z.boolean().optional(),
+	mode: z.enum([
+		"web",
+		"node",
+		"storybook"
+	]).optional(),
+	entry: z.string().min(1).optional(),
+	entries: z.record(z.string().min(1), z.string().min(1)).optional(),
+	outDir: z.string().min(1).optional(),
+	declaration: z.union([z.boolean(), nativeConfigSchema()]).optional(),
+	sourcemap: z.boolean().optional(),
+	minify: z.boolean().optional(),
+	copy: z.array(copyMappingSchema).optional(),
+	formats: z.array(z.enum(["esm", "cjs"])).min(1).optional(),
+	platform: z.enum([
+		"node",
+		"browser",
+		"neutral"
+	]).optional(),
+	target: syntaxTargetSchema.optional()
+});
+const formatConfigSchema = nativeConfigSchema();
+const lintConfigSchema = nativeConfigSchema();
+const rolldownConfigSchema = nativeConfigSchema();
+const testConfigSchema = nativeConfigSchema();
+const viteConfigSchema = nativeConfigSchema();
+const storybookConfigSchema = z.strictObject({
+	configDir: z.string().min(1).optional(),
+	outDir: z.string().min(1).optional(),
+	test: z.boolean().optional()
+});
+const pluginSchema = z.custom(isWebAnvilPlugin, "Expected a Vite plugin or a WebAnvil plugin created with definePlugin()");
+const userConfigSchema = z.strictObject({
+	build: buildConfigSchema.optional(),
+	format: formatConfigSchema.optional(),
+	lint: lintConfigSchema.optional(),
+	rolldown: rolldownConfigSchema.optional(),
+	storybook: storybookConfigSchema.optional(),
+	test: testConfigSchema.optional(),
+	vite: viteConfigSchema.optional(),
+	plugins: z.array(pluginSchema).optional()
+});
+const effectiveUserConfigSchema = userConfigSchema.superRefine((config, context) => {
+	const build = config.build ?? {};
+	if (build.entries !== void 0 && build.mode !== "node") context.addIssue({
+		code: "custom",
+		path: ["build", "entries"],
+		message: "build.entries is only available in Node mode"
+	});
+	if (build.mode === "web" && build.platform !== void 0) context.addIssue({
+		code: "custom",
+		path: ["build", "platform"],
+		message: "Web builds do not accept build.platform"
+	});
+	if (build.mode === "node") {
+		for (const [index, plugin] of (config.plugins ?? []).entries()) if (!isUnpluginAdapter(plugin)) context.addIssue({
+			code: "custom",
+			path: ["plugins", index],
+			message: NODE_PLUGIN_ERROR
+		});
+	}
+});
+const defaultConfig = {
+	build: {
+		mode: "node",
+		entry: "src/index.ts",
+		outDir: "dist"
+	},
+	test: { environment: "node" }
+};
+const toCommandArguments = (config) => Object.fromEntries(Object.entries(config).filter(([, value]) => value !== void 0).map(([key, value]) => [key.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`), value]));
+const defined = (arguments_) => Object.fromEntries(Object.entries(arguments_).filter(([, value]) => value !== void 0));
+const defineConfig = (config) => config;
+const loadConfig$1 = async (cwd = process.cwd()) => {
+	const { config, configFile } = await loadConfig({
+		name: "webanvil",
+		cwd,
+		configFile: "webanvil.config",
+		packageJson: false,
+		rcFile: false
+	});
+	return {
+		config: userConfigSchema.parse(defu(config, defaultConfig)),
+		configFile
+	};
+};
+const resolveEffectiveBuildConfig = (config, overrides, explicitEntry) => {
+	const build = {
+		...config.build,
+		...defined(overrides)
+	};
+	if (explicitEntry) delete build.entries;
+	return effectiveUserConfigSchema.parse({
+		...config,
+		build
+	}).build ?? {};
+};
+const withConfig = (select, run) => async (arguments_, resolvedConfig) => {
+	const config = resolvedConfig ?? (await loadConfig$1()).config;
+	const selectedConfig = select(config) ?? {};
+	return run({
+		...toCommandArguments(selectedConfig),
+		...defined(arguments_)
+	}, selectedConfig, config, arguments_);
+};
+export { assertSyntaxTarget, buildConfigSchema, copyMappingSchema, defaultConfig, defineConfig, definePlugin, effectiveUserConfigSchema, formatConfigSchema, isUnpluginAdapter, isWebAnvilPlugin, lintConfigSchema, loadConfig$1 as loadConfig, resolveEffectiveBuildConfig, resolveRolldownPlugins, resolveVitePlugins, rolldownConfigSchema, storybookConfigSchema, syntaxTargetSchema, testConfigSchema, userConfigSchema, viteConfigSchema, withConfig };

package/dist/_chunks/project-vite.mjs

@@ -0,0 +1,9 @@
+import { loadConfig, resolveVitePlugins } from "./config.mjs";
+const withProjectVitePlugins = async (config) => {
+	const { config: webanvilConfig } = await loadConfig();
+	return {
+		...config,
+		plugins: [...config.plugins ?? [], ...resolveVitePlugins(webanvilConfig.plugins ?? [])]
+	};
+};
+export { withProjectVitePlugins };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,30 @@
+import { build_default, check_default, clean_default, dev_default, format_default, lint_default, logger, preview_default, test_default, typecheck_default } from "./_chunks/commands.mjs";
+import { execute } from "cmdore";
+import { fileURLToPath } from "node:url";
+import { readPackageJSON } from "pkg-types";
+const main = async (...varargs) => {
+	const packageJson = await readPackageJSON(fileURLToPath(new URL("..", import.meta.url)));
+	return execute([
+		build_default,
+		check_default,
+		clean_default,
+		dev_default,
+		format_default,
+		lint_default,
+		preview_default,
+		test_default,
+		typecheck_default
+	], {
+		argv: varargs,
+		metadata: {
+			name: packageJson.name ?? "webanvil",
+			version: packageJson.version
+		},
+		onError: "throw"
+	});
+};
+main(...process.argv.slice(2)).then((code) => process.exit(code)).catch((error) => {
+	logger.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+});
+export {};