@samva/vite 0.1.2 → 0.2.0

package/dist/project.d.ts

@@ -0,0 +1,116 @@
+import { EmailProjectSource, EmailRenderer, LoadedEmailEntry } from "./email.js";
+import { AssetEntry, RenderedEmail, TransformOptions } from "@samva/markup/compiler";
+import { TemplateDefinition, isTemplateDefinition } from "@samva/markup/template";
+import { EmailDiagnostic } from "@samva/markup/email/diagnostics";
+import { SerializeEmailOptions } from "@samva/markup/email/html";
+//#region src/project.d.ts
+/**
+ * Read a project directory into the source map the compiler consumes. Text
+ * modules arrive as strings and imported files as bytes, which is the same
+ * shape the hosted build hands `compileEmailProject`.
+ */
+declare const readEmailProject: (dir: string) => Promise<EmailProjectSource>;
+/** One discovered template: its declared identity and the entry that declares it. */
+interface EmailCatalogEntry {
+  /** The identity the definition declares for itself. */
+  readonly id: string;
+  /** Project-relative path of the authored entry. */
+  readonly entryPath: string;
+  readonly definition: TemplateDefinition<unknown>;
+  readonly loaded: LoadedEmailEntry;
+}
+interface EmailCatalog {
+  readonly templates: readonly EmailCatalogEntry[];
+  /** Candidate entries that turned out to be ordinary modules. */
+  readonly helpers: readonly string[];
+  readonly diagnostics: readonly EmailDiagnostic[];
+  /** Every asset the discovered templates import, deduplicated by content. */
+  readonly assets: readonly AssetEntry[];
+}
+/**
+ * Compile and evaluate every candidate entry, keeping the ones that declare a
+ * template. Compilation is per entry, exactly as a publication is per template,
+ * so shared components and CSS reach each template the same way they reach the
+ * hosted build.
+ */
+declare const loadEmailCatalog: (input: {
+  readonly renderer: EmailRenderer;
+  readonly files: EmailProjectSource;
+  readonly entryPaths?: readonly string[] | undefined;
+  /**
+   * Reuse one id namespace per entry so a reload replaces its modules instead
+   * of accumulating a new namespace per pass. A watch session sets this; a
+   * one-shot load leaves each entry isolated.
+   */
+  readonly stableNamespaces?: boolean | undefined;
+}) => Promise<EmailCatalog>;
+/** One fixture rendered through the template it belongs to. */
+interface RenderedFixture {
+  readonly templateId: string;
+  readonly fixture: string;
+  readonly rendered: RenderedEmail | undefined;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * Validate and render every fixture a template declares. A fixture that its own
+ * schema rejects is a source defect the author sees here rather than at publish.
+ */
+declare const renderEmailFixtures: (entry: EmailCatalogEntry, options?: SerializeEmailOptions) => readonly RenderedFixture[];
+/** A live catalog over a project directory, reloaded when its source changes. */
+interface EmailProjectSession {
+  readonly reload: () => Promise<EmailCatalog>;
+  readonly current: () => EmailCatalog;
+  readonly subscribe: (listener: (path: string) => void) => () => void;
+  readonly close: () => Promise<void>;
+}
+/**
+ * The authoring loop: one evaluator, one catalog, reloaded on change. Content
+ * semantics come from `compileEmailProject` and `renderEmail`, the same two
+ * calls the hosted preview makes, so what an author iterates on locally is what
+ * a publication renders.
+ */
+declare const createEmailProjectSession: (dir: string, options: TransformOptions) => Promise<EmailProjectSession>;
+interface EmailExportReceipt {
+  readonly templates: readonly {
+    readonly id: string;
+    readonly entryPath: string;
+    readonly fixtures: readonly {
+      readonly fixture: string;
+      readonly html: string;
+      readonly text: string;
+    }[];
+  }[];
+  readonly assets: {
+    readonly base: string;
+    readonly assets: readonly AssetEntry[];
+  };
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * Where an export serves its assets from when the caller names no origin.
+ *
+ * An export writes one page at `templates/<id>/<fixture>.html` and every asset
+ * once at `assets/<content address>`, so the base a page resolves against is
+ * the path from its own directory back to that one. A template id is one path
+ * segment, so every page sits at the same depth and one base serves them all.
+ */
+declare const DEFAULT_EXPORT_ASSET_BASE = "../../assets";
+/**
+ * Render every template's fixtures to HTML and text beside the bytes of every
+ * asset they reference, with the manifest that maps each address to its file.
+ *
+ * The export renders in the compiler's export mode, so a relative `assetBase`
+ * is accepted and the written page resolves its images from the directory it
+ * sits in. Delivery keeps refusing relative references — an inbox has no
+ * directory to resolve one against — so an export destined for sending names
+ * the https origin it will be served from instead.
+ */
+declare const exportEmailProject: (input: {
+  readonly dir: string;
+  readonly out: string;
+  readonly assetBase?: string | undefined;
+  readonly tailwind?: TransformOptions["tailwind"] | undefined;
+}) => Promise<EmailExportReceipt>;
+//#endregion
+export { DEFAULT_EXPORT_ASSET_BASE, EmailCatalog, EmailCatalogEntry, EmailExportReceipt, EmailProjectSession, RenderedFixture, createEmailProjectSession, exportEmailProject, isTemplateDefinition, loadEmailCatalog, readEmailProject, renderEmailFixtures };
+//# sourceMappingURL=project.d.ts.map

package/dist/project.js

@@ -0,0 +1,294 @@
+import { createEmailRenderer } from "./email.js";
+import { watch } from "node:fs";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { assetUrl, isAssetPath } from "@samva/markup/compiler";
+import { TEMPLATE_NAME_PATTERN, isTemplateDefinition, isTemplateDefinition as isTemplateDefinition$1 } from "@samva/markup/template";
+//#region src/project.ts
+const toPosix = (value) => sep === "/" ? value : value.split(sep).join("/");
+const isCandidateEntry = (path) => path.endsWith(".tsx");
+const diagnostic = (code, severity, message) => ({
+	code,
+	severity,
+	message,
+	origins: []
+});
+/**
+* Read a project directory into the source map the compiler consumes. Text
+* modules arrive as strings and imported files as bytes, which is the same
+* shape the hosted build hands `compileEmailProject`.
+*/
+const readEmailProject = async (dir) => {
+	const root = resolve(dir);
+	const files = {};
+	const walk = async (current) => {
+		const entries = await readdir(current, { withFileTypes: true });
+		await Promise.all(entries.filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules").map(async (entry) => {
+			const full = join(current, entry.name);
+			if (entry.isDirectory()) return walk(full);
+			if (!entry.isFile()) return;
+			const path = toPosix(relative(root, full));
+			files[path] = isAssetPath(path) ? new Uint8Array(await readFile(full)) : await readFile(full, "utf8");
+		}));
+	};
+	await walk(root);
+	return files;
+};
+/**
+* Compile and evaluate every candidate entry, keeping the ones that declare a
+* template. Compilation is per entry, exactly as a publication is per template,
+* so shared components and CSS reach each template the same way they reach the
+* hosted build.
+*/
+const loadEmailCatalog = async (input) => {
+	const candidates = (input.entryPaths ?? Object.keys(input.files).filter(isCandidateEntry)).slice();
+	candidates.sort();
+	const templates = [];
+	const helpers = [];
+	const diagnostics = [];
+	const assets = /* @__PURE__ */ new Map();
+	const declaredBy = /* @__PURE__ */ new Map();
+	const loaded = await Promise.all(candidates.map((entryPath) => loadEntry(input.renderer, input.files, entryPath, input.stableNamespaces === true ? entryPath : void 0)));
+	for (const [index, entryPath] of candidates.entries()) {
+		const result = loaded[index];
+		if (!result.ok) {
+			diagnostics.push(diagnostic("entry-load-error", "error", `${entryPath}: ${result.message}`));
+			continue;
+		}
+		const template = result.entry.template;
+		if (template === void 0) {
+			helpers.push(entryPath);
+			continue;
+		}
+		if (!isTemplateDefinition$1(template)) {
+			helpers.push(entryPath);
+			diagnostics.push(diagnostic("not-a-template", "warning", `${entryPath} default-exports something that is not a template definition. Wrap it with defineEmail, or drop the default export so it reads as a helper module.`));
+			continue;
+		}
+		const previous = declaredBy.get(template.id);
+		if (previous !== void 0) {
+			diagnostics.push(diagnostic("duplicate-template-id", "error", `Template id ${JSON.stringify(template.id)} is declared by both ${previous} and ${entryPath}. An id is a publication's identity, so it must name exactly one template.`));
+			continue;
+		}
+		declaredBy.set(template.id, entryPath);
+		for (const asset of result.entry.compiled.assets) assets.set(asset.digest, asset);
+		diagnostics.push(...result.entry.compiled.diagnostics);
+		templates.push({
+			id: template.id,
+			entryPath,
+			definition: template,
+			loaded: result.entry
+		});
+	}
+	return {
+		templates: templates.sort((left, right) => left.id < right.id ? -1 : 1),
+		helpers,
+		diagnostics,
+		assets: [...assets.values()].sort((left, right) => left.fileName < right.fileName ? -1 : 1)
+	};
+};
+const loadEntry = async (renderer, files, entryPath, namespace) => renderer.load(files, entryPath, namespace).then((entry) => ({
+	ok: true,
+	entry
+}), (cause) => ({
+	ok: false,
+	message: cause instanceof Error ? cause.message : String(cause)
+}));
+/**
+* Validate and render every fixture a template declares. A fixture that its own
+* schema rejects is a source defect the author sees here rather than at publish.
+*/
+const renderEmailFixtures = (entry, options = {}) => Object.entries(entry.definition.fixtures).map(([fixture, data]) => {
+	if (!entry.definition.schema.validate(data)) return {
+		templateId: entry.id,
+		fixture,
+		rendered: void 0,
+		diagnostics: [diagnostic("invalid-fixture", "error", `Fixture ${JSON.stringify(fixture)} does not satisfy ${entry.id}'s own input schema: ${JSON.stringify(entry.definition.schema.validate.errors)}`)]
+	};
+	try {
+		const rendered = entry.loaded.renderEmail(entry.definition, data, options);
+		return {
+			templateId: entry.id,
+			fixture,
+			rendered,
+			diagnostics: rendered.diagnostics
+		};
+	} catch (cause) {
+		return {
+			templateId: entry.id,
+			fixture,
+			rendered: void 0,
+			diagnostics: findingsOf(cause, entry.id, fixture)
+		};
+	}
+});
+const findingsOf = (cause, templateId, fixture) => {
+	const carried = cause.diagnostics;
+	if (Array.isArray(carried) && carried.length > 0) return carried;
+	return [diagnostic("render-failed", "error", `${templateId} could not render fixture ${JSON.stringify(fixture)}: ${cause instanceof Error ? cause.message : String(cause)}`)];
+};
+/**
+* The authoring loop: one evaluator, one catalog, reloaded on change. Content
+* semantics come from `compileEmailProject` and `renderEmail`, the same two
+* calls the hosted preview makes, so what an author iterates on locally is what
+* a publication renders.
+*/
+const createEmailProjectSession = async (dir, options) => {
+	const root = resolve(dir);
+	const renderer = await createEmailRenderer(options);
+	let catalog = {
+		templates: [],
+		helpers: [],
+		diagnostics: [],
+		assets: []
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const observer = watch(root, { recursive: true }, (_event, name) => {
+		const changed = name === null ? root : toPosix(name.toString());
+		for (const listener of listeners) listener(changed);
+	});
+	const reload = async () => {
+		renderer.invalidate();
+		catalog = await loadEmailCatalog({
+			renderer,
+			files: await readEmailProject(root),
+			stableNamespaces: true
+		});
+		return catalog;
+	};
+	return {
+		reload,
+		current: () => catalog,
+		subscribe: (listener) => {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		},
+		close: async () => {
+			observer.close();
+			listeners.clear();
+			await renderer.close();
+		}
+	};
+};
+/**
+* Where an export serves its assets from when the caller names no origin.
+*
+* An export writes one page at `templates/<id>/<fixture>.html` and every asset
+* once at `assets/<content address>`, so the base a page resolves against is
+* the path from its own directory back to that one. A template id is one path
+* segment, so every page sits at the same depth and one base serves them all.
+*/
+const DEFAULT_EXPORT_ASSET_BASE = "../../assets";
+/**
+* The path an export writes, or `undefined` when a name would leave the root.
+*
+* `defineEmail` already refuses an id or a fixture key that is not one path
+* segment, so this is the guard rather than the contract: the same pattern,
+* plus a containment check, so a name that reaches `join` can never address a
+* file the export does not own.
+*/
+const exportPath = (out, ...segments) => {
+	if (!segments.every((segment) => TEMPLATE_NAME_PATTERN.test(segment))) return void 0;
+	const path = join(out, ...segments);
+	const inside = relative(out, path);
+	return inside === "" || inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside) ? void 0 : path;
+};
+const unsafeExportName = (kind, value) => diagnostic("unsafe-export-name", "error", `${kind} ${JSON.stringify(value)} is not one path segment, so an export cannot write a file for it. Use letters, digits, ".", "_" and "-", starting with a letter, digit or "_".`);
+/**
+* Render every template's fixtures to HTML and text beside the bytes of every
+* asset they reference, with the manifest that maps each address to its file.
+*
+* The export renders in the compiler's export mode, so a relative `assetBase`
+* is accepted and the written page resolves its images from the directory it
+* sits in. Delivery keeps refusing relative references — an inbox has no
+* directory to resolve one against — so an export destined for sending names
+* the https origin it will be served from instead.
+*/
+const exportEmailProject = async (input) => {
+	const out = resolve(input.out);
+	const files = await readEmailProject(input.dir);
+	const base = input.assetBase ?? "../../assets";
+	const renderer = await createEmailRenderer({
+		assetBase: base,
+		...input.tailwind === void 0 ? {} : { tailwind: input.tailwind }
+	});
+	try {
+		const catalog = await loadEmailCatalog({
+			renderer,
+			files
+		});
+		const diagnostics = [...catalog.diagnostics];
+		const written = await Promise.all(catalog.templates.map(async (entry) => {
+			const directory = exportPath(out, "templates", entry.id);
+			if (directory === void 0) return {
+				entry: void 0,
+				diagnostics: [unsafeExportName("Template id", entry.id)]
+			};
+			await mkdir(directory, { recursive: true });
+			const rendered = renderEmailFixtures(entry, { relativeUrls: true });
+			const pages = await Promise.all(rendered.map(async (result) => {
+				if (result.rendered === void 0) return {
+					fixture: void 0,
+					diagnostics: []
+				};
+				const htmlPath = exportPath(out, "templates", entry.id, `${result.fixture}.html`);
+				const textPath = exportPath(out, "templates", entry.id, `${result.fixture}.txt`);
+				if (htmlPath === void 0 || textPath === void 0) return {
+					fixture: void 0,
+					diagnostics: [unsafeExportName("Fixture name", result.fixture)]
+				};
+				await Promise.all([writeFile(htmlPath, result.rendered.html, "utf8"), writeFile(textPath, result.rendered.text, "utf8")]);
+				return {
+					fixture: {
+						fixture: result.fixture,
+						html: toPosix(relative(out, htmlPath)),
+						text: toPosix(relative(out, textPath))
+					},
+					diagnostics: []
+				};
+			}));
+			return {
+				entry: {
+					id: entry.id,
+					entryPath: entry.entryPath,
+					fixtures: pages.map((result) => result.fixture).filter((fixture) => fixture !== void 0)
+				},
+				diagnostics: [...rendered.flatMap((result) => result.diagnostics), ...pages.flatMap((result) => result.diagnostics)]
+			};
+		}));
+		const templates = written.map((result) => result.entry).filter((entry) => entry !== void 0);
+		diagnostics.push(...written.flatMap((result) => result.diagnostics));
+		const assetDirectory = join(out, "assets");
+		if (catalog.assets.length > 0) await mkdir(assetDirectory, { recursive: true });
+		await Promise.all(catalog.assets.map((asset) => {
+			const bytes = files[asset.path];
+			return bytes === void 0 || typeof bytes === "string" ? Promise.resolve() : writeFile(join(assetDirectory, asset.fileName), bytes);
+		}));
+		const receipt = {
+			templates,
+			assets: {
+				base,
+				assets: catalog.assets
+			},
+			diagnostics
+		};
+		await mkdir(out, { recursive: true });
+		await writeFile(join(out, "catalog.json"), `${JSON.stringify({
+			...receipt,
+			assets: {
+				base,
+				assets: catalog.assets.map((asset) => ({
+					...asset,
+					url: assetUrl(asset, base)
+				}))
+			}
+		}, null, 2)}\n`, "utf8");
+		return receipt;
+	} finally {
+		await renderer.close();
+	}
+};
+//#endregion
+export { DEFAULT_EXPORT_ASSET_BASE, createEmailProjectSession, exportEmailProject, isTemplateDefinition, loadEmailCatalog, readEmailProject, renderEmailFixtures };
+
+//# sourceMappingURL=project.js.map

package/dist/theme-CBF6Czjm.js

@@ -0,0 +1,50 @@
+import { readFile, readdir } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+//#region src/discovery.ts
+const isTemplateFile = (name) => name.endsWith(".tsx");
+const toPosix = (value) => sep === "/" ? value : value.split(sep).join("/");
+/**
+* Recursively lists template files under `dir`. Hidden entries and
+* `node_modules` are skipped. Results are sorted by id for deterministic
+* ordering (the preview list and build output must be stable).
+*/
+const discoverTemplateFiles = async (dir) => {
+	const found = [];
+	const walk = async (current) => {
+		const visible = (await readdir(current, { withFileTypes: true })).filter((entry) => !entry.name.startsWith(".") && entry.name !== "node_modules");
+		await Promise.all(visible.map(async (entry) => {
+			const full = join(current, entry.name);
+			if (entry.isDirectory()) {
+				await walk(full);
+				return;
+			}
+			if (!isTemplateFile(entry.name)) return;
+			found.push({
+				path: full,
+				id: toPosix(relative(dir, full)),
+				kind: "tsx"
+			});
+		}));
+	};
+	await walk(dir);
+	return found.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+};
+/**
+* Resolves the `theme` plugin option to an absolute path, or `undefined` when
+* theming is explicitly disabled (`theme: false`). A string is taken relative to
+* `root` (absolute strings pass through); the default is `<root>/theme.css`.
+*/
+const resolveThemePath = (root, option) => {
+	if (option === false) return void 0;
+	const file = option ?? "theme.css";
+	return isAbsolute(file) ? file : resolve(root, file);
+};
+/** Read authored Tailwind CSS verbatim; the email compiler validates its syntax. */
+const readProjectThemeCss = async (path) => path === void 0 ? void 0 : readFile(path, "utf8").catch((cause) => {
+	if (cause.code === "ENOENT") return void 0;
+	throw cause;
+});
+//#endregion
+export { resolveThemePath as n, discoverTemplateFiles as r, readProjectThemeCss as t };
+
+//# sourceMappingURL=theme-CBF6Czjm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samva/vite",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Unified Vite editor for Samva email, SMS, and WhatsApp templates",
   "keywords": [
     "email",
@@ -45,39 +45,47 @@
     "./build": {
       "types": "./dist/build.d.ts",
       "import": "./dist/build.js"
+    },
+    "./project": {
+      "types": "./dist/project.d.ts",
+      "import": "./dist/project.js"
+    },
+    "./email": {
+      "types": "./dist/email.d.ts",
+      "import": "./dist/email.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "NODE_ENV=production tsdown && NODE_ENV=production vite build --config editor/vite.config.ts",
-    "build:editor": "NODE_ENV=production vite build --config editor/vite.config.ts",
-    "dev:editor": "vite --config editor/vite.config.ts",
+    "build": "NODE_ENV=production tsdown && bun run build:editor",
+    "build:editor": "bun run --filter @samva/vite-editor-app build",
+    "dev:editor": "bun run --filter @samva/vite-editor-app dev",
     "prepack": "bun run build",
-    "typecheck": "tsgo --noEmit && tsgo --noEmit -p editor/tsconfig.json",
-    "test": "vitest run --root ../.. --project packages packages/vite/tests"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --root ../.. --project packages packages/vite/tests",
+    "test:browser": "turbo run build --filter=@samva/vite && playwright test --config playwright.config.ts --project chromium",
+    "test:browser:cross": "turbo run build --filter=@samva/vite && playwright test --config playwright.config.ts"
   },
   "dependencies": {
-    "@samva/markup": "^0.1.2",
-    "effect": "4.0.0-rc.111"
+    "@babel/parser": "^8.0.4",
+    "@samva/markup": "^0.2.0",
+    "caniemail": "2.0.2",
+    "css-tree": "3.2.1",
+    "effect": "4.0.0-rc.112",
+    "tailwindcss": "^4.3.3"
   },
   "devDependencies": {
-    "@effect/vitest": "4.0.0-rc.111",
-    "@tailwindcss/vite": "^4.3.3",
-    "@types/react": "19.2.18",
-    "@types/react-dom": "19.2.4",
-    "@vitejs/plugin-react": "^6.0.5",
-    "react": "19.2.8",
-    "react-dom": "19.2.8",
-    "tailwindcss": "^4.3.3",
+    "@effect/vitest": "4.0.0-rc.112",
+    "@playwright/test": "^1.62.1",
     "tsdown": "^0.22.13",
-    "typescript": "^6.0.3",
-    "vite": "~8.2.0",
-    "vitest": "^4.1.10"
+    "typescript": "^7.0.2",
+    "vite": "~8.2.2",
+    "vitest": "^4.1.11"
   },
   "peerDependencies": {
-    "vite": "^7.0.0 || ^8.0.0"
+    "vite": "^8.2.2"
   },
   "engines": {
     "node": ">=22"