@coreframe/vite 0.1.0

package/dist/assets.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from "vite";
+
+//#region assets.d.ts
+type CoreframeAssetsPluginOptions = {
+  devMaterialize?: boolean;
+  cwd?: string;
+};
+declare function coreframeAssetsPlugin({
+  cwd,
+  devMaterialize
+}?: CoreframeAssetsPluginOptions): Plugin;
+//#endregion
+export { CoreframeAssetsPluginOptions, coreframeAssetsPlugin };

package/dist/assets.js

@@ -0,0 +1,83 @@
+import { checkAssets, formatAssetProblems, materializeAsset, readAssetManifest } from "@coreframe/scripts/assets";
+
+//#region assets.ts
+const manifestPath = "assets/manifest.json";
+const markdownAssetReferencePattern = /@asset\s+([a-z0-9][a-z0-9/-]*)/g;
+function coreframeAssetsPlugin({ cwd = process.cwd(), devMaterialize = true } = {}) {
+	const virtualId = "virtual:assets";
+	const resolvedVirtualId = `\0${virtualId}`;
+	return {
+		name: "coreframe:assets",
+		async buildStart() {
+			if (this.meta.watchMode) return;
+			const status = await checkAssets({ cwd });
+			if (!status.ok) throw new Error(formatAssetProblems(status.problems));
+		},
+		async resolveId(id) {
+			if (id === virtualId) return resolvedVirtualId;
+		},
+		async load(id) {
+			if (id !== resolvedVirtualId) return;
+			const { manifest, problems } = await readAssetManifest(cwd);
+			if (problems.length > 0) throw new Error(formatAssetProblems(problems));
+			return [
+				`const manifest = ${JSON.stringify(manifest)};`,
+				"export { manifest };",
+				"export function asset(id) {",
+				"  const entry = manifest[id];",
+				"  if (!entry) throw new Error(`Unknown Coreframe asset: ${id}`);",
+				"  return entry;",
+				"}"
+			].join("\n");
+		},
+		async transform(code, id) {
+			const assetIds = [...code.matchAll(markdownAssetReferencePattern)].map((match) => match[1]);
+			if (assetIds.length === 0) return;
+			const loaded = await readAssetManifest(cwd);
+			const problems = [...loaded.problems];
+			let transformed = code;
+			for (const assetId of assetIds) {
+				const entry = loaded.manifest[assetId];
+				if (!entry) {
+					problems.push({
+						code: "INVALID_REFERENCE",
+						message: `Asset reference "${assetId}" in "${id}" is not present in ${manifestPath}.`,
+						assetId,
+						file: id
+					});
+					continue;
+				}
+				if (this.meta.watchMode && devMaterialize && entry.variants.length === 0) {
+					this.warn(`Materializing Coreframe asset "${assetId}" for dev.`);
+					const result = await materializeAsset(assetId, {
+						cwd,
+						updateManifest: false
+					});
+					problems.push(...result.problems);
+					const materialized = result.assets.find((asset) => asset.assetId === assetId);
+					if (materialized) loaded.manifest[assetId] = {
+						...entry,
+						variants: materialized.variants
+					};
+				}
+				const variant = loaded.manifest[assetId]?.variants[0];
+				if (!variant) {
+					problems.push({
+						code: "GENERATED_VARIANT_MISSING",
+						message: `Asset "${assetId}" has no generated variant.`,
+						assetId,
+						file: id,
+						fix: `Run: coreframe assets build --id ${assetId}`
+					});
+					continue;
+				}
+				transformed = transformed.replaceAll(`@asset ${assetId}`, `/${variant.path}`);
+			}
+			if (problems.length > 0) throw new Error(formatAssetProblems(problems));
+			return transformed;
+		}
+	};
+}
+
+//#endregion
+export { coreframeAssetsPlugin };

package/dist/image-generator.d.ts

@@ -0,0 +1,18 @@
+import { ConfigEnv, FSWatcher } from "vite";
+
+//#region image-generator.d.ts
+declare function imageGenerator(): {
+  name: string;
+  configResolved(config: {
+    command: ConfigEnv["command"];
+  }): void;
+  configureServer(server: {
+    watcher: FSWatcher;
+  }): Promise<void>;
+  applyToEnvironment(environment: {
+    name: string;
+  }): boolean;
+  buildStart(): Promise<void>;
+};
+//#endregion
+export { imageGenerator };

package/dist/image-generator.js

@@ -0,0 +1,79 @@
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "tinyglobby";
+
+//#region image-generator.ts
+function imageGenerator() {
+	let command;
+	return {
+		name: "image-generator",
+		configResolved(config) {
+			command = config.command;
+		},
+		async configureServer(server) {
+			await generateAllDensityImages();
+			server.watcher.on("add", (file) => {
+				if (isSourceDensityImage(file)) generateDensityImages(file);
+			});
+			server.watcher.on("change", (file) => {
+				if (isSourceDensityImage(file)) generateDensityImages(file, { overwrite: true });
+			});
+		},
+		applyToEnvironment(environment) {
+			return environment.name === "client";
+		},
+		async buildStart() {
+			if (command === "build") await generateAllDensityImages();
+		}
+	};
+}
+async function generateAllDensityImages() {
+	const files = await glob(["src/**/*@3x.{png,webp}", "public/**/*@3x.{png,webp}"]);
+	console.log(`[image-generator] Found ${files.length} @3x images.`);
+	await Promise.all(files.map((file) => generateDensityImages(file)));
+}
+function isSourceDensityImage(file) {
+	return /@3x\.(png|webp)$/.test(file);
+}
+async function generateDensityImages(file, options = {}) {
+	const dir = path.dirname(file);
+	const ext = path.extname(file);
+	const base = path.basename(file, `@3x${ext}`);
+	const outputImages = [{
+		outputPath: path.join(dir, `${base}@2x${ext}`),
+		scale: 2 / 3
+	}, {
+		outputPath: path.join(dir, `${base}@1x${ext}`),
+		scale: 1 / 3
+	}].filter((image) => options.overwrite || !fs.existsSync(image.outputPath));
+	if (outputImages.length === 0) return;
+	const { default: sharp } = await import("sharp");
+	let width;
+	try {
+		width = (await sharp(file).metadata()).width;
+	} catch (error) {
+		console.error(`[image-generator] Failed to read metadata for ${file}`, error);
+		return;
+	}
+	if (!width) {
+		console.error(`[image-generator] Skipping ${file}; image width could not be read.`);
+		return;
+	}
+	await Promise.all(outputImages.map((image) => generateDensityImage({
+		file,
+		outputPath: image.outputPath,
+		sharp,
+		width: Math.round(width * image.scale)
+	})));
+}
+async function generateDensityImage(options) {
+	try {
+		console.log(`[image-generator] Generating ${options.outputPath} (${options.width}w)`);
+		await options.sharp(options.file).resize({ width: options.width }).toFile(options.outputPath);
+	} catch (error) {
+		console.error(`[image-generator] Failed to process ${options.file} for ${options.outputPath}`, error);
+	}
+}
+
+//#endregion
+export { imageGenerator };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import { ConfigEnv, PluginOption } from "vite";
+
+//#region index.d.ts
+type CoreframeRunner = "tauri" | "vitest" | "react-router-ssg" | null;
+type CoreframeConfigEnv = ConfigEnv & {
+  runner: CoreframeRunner;
+};
+type PluginFilter = (env: CoreframeConfigEnv) => boolean;
+type PluginSelector = (env: CoreframeConfigEnv) => PluginOption;
+type SelectablePlugin = PluginOption | PluginSelector;
+declare function extendConfigEnv(env: ConfigEnv, processEnv?: NodeJS.ProcessEnv): CoreframeConfigEnv;
+declare function selectPlugins(env: CoreframeConfigEnv, plugins: readonly SelectablePlugin[]): PluginOption[];
+declare function apply(filter: PluginFilter, plugin: SelectablePlugin): PluginSelector;
+declare function buildOnly(plugin: SelectablePlugin): PluginSelector;
+declare function devOnly(plugin: SelectablePlugin): PluginSelector;
+declare function runnerOnly(runners: CoreframeRunner | readonly CoreframeRunner[], plugin: SelectablePlugin): PluginSelector;
+declare function exceptRunner(runners: CoreframeRunner | readonly CoreframeRunner[], plugin: SelectablePlugin): PluginSelector;
+//#endregion
+export { CoreframeConfigEnv, CoreframeRunner, PluginFilter, PluginSelector, SelectablePlugin, apply, buildOnly, devOnly, exceptRunner, extendConfigEnv, runnerOnly, selectPlugins };

package/dist/index.js

@@ -0,0 +1,34 @@
+//#region index.ts
+function extendConfigEnv(env, processEnv = process.env) {
+	return {
+		...env,
+		runner: processEnv.TAURI_ENV_PLATFORM !== void 0 ? "tauri" : processEnv.VITEST === "true" ? "vitest" : processEnv.IS_RR_BUILD_REQUEST === "yes" ? "react-router-ssg" : null
+	};
+}
+function selectPlugins(env, plugins) {
+	return plugins.map((plugin) => selectPlugin(env, plugin));
+}
+function apply(filter, plugin) {
+	return (env) => filter(env) ? selectPlugin(env, plugin) : null;
+}
+function buildOnly(plugin) {
+	return apply((env) => env.command === "build", plugin);
+}
+function devOnly(plugin) {
+	return apply((env) => env.command === "serve", plugin);
+}
+function runnerOnly(runners, plugin) {
+	return apply((env) => includesRunner(runners, env.runner), plugin);
+}
+function exceptRunner(runners, plugin) {
+	return apply((env) => !includesRunner(runners, env.runner), plugin);
+}
+function selectPlugin(env, plugin) {
+	return typeof plugin === "function" ? plugin(env) : plugin;
+}
+function includesRunner(runners, runner) {
+	return (typeof runners === "string" || runners === null ? [runners] : runners).includes(runner);
+}
+
+//#endregion
+export { apply, buildOnly, devOnly, exceptRunner, extendConfigEnv, runnerOnly, selectPlugins };

package/dist/markdown-frontmatter.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "vite";
+
+//#region markdown-frontmatter.d.ts
+type MarkdownFrontmatterPluginOptions = {
+  contentDirectory: string;
+};
+declare function markdownFrontmatterPlugin({
+  contentDirectory
+}: MarkdownFrontmatterPluginOptions): Plugin;
+//#endregion
+export { MarkdownFrontmatterPluginOptions, markdownFrontmatterPlugin };

package/dist/markdown-frontmatter.js

@@ -0,0 +1,20 @@
+import { normalizePath } from "vite";
+
+//#region markdown-frontmatter.ts
+const markdownFrontmatterPattern = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/;
+function markdownFrontmatterPlugin({ contentDirectory }) {
+	const normalizedContentDirectory = `${normalizePath(contentDirectory).replace(/\/+$/, "")}/`;
+	return {
+		name: "coreframe:markdown-frontmatter",
+		enforce: "pre",
+		transform(code, id) {
+			const [path = "", query] = id.split("?");
+			const normalizedPath = normalizePath(path);
+			if (query || !normalizedPath.startsWith(normalizedContentDirectory) || !path.endsWith(".md")) return;
+			return code.replace(markdownFrontmatterPattern, "");
+		}
+	};
+}
+
+//#endregion
+export { markdownFrontmatterPlugin };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@coreframe/vite",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/airlock-labs/coreframe.git",
+    "directory": "vite"
+  },
+  "files": [
+    "dist/"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./assets": {
+      "types": "./dist/assets.d.ts",
+      "default": "./dist/assets.js"
+    },
+    "./image-generator": {
+      "types": "./dist/image-generator.d.ts",
+      "default": "./dist/image-generator.js"
+    },
+    "./markdown-frontmatter": {
+      "types": "./dist/markdown-frontmatter.d.ts",
+      "default": "./dist/markdown-frontmatter.js"
+    }
+  },
+  "dependencies": {
+    "tinyglobby": "^0.2.17",
+    "@coreframe/scripts": "^0.1.11"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.0",
+    "sharp": "^0.34.5",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "vite": "^8.1.0",
+    "vitest": "^4.1.9"
+  },
+  "peerDependencies": {
+    "sharp": "^0.34.5 || ^0.35.0",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "format": "oxfmt",
+    "lint": "oxlint"
+  }
+}