@samva/vite 0.7.0 → 0.8.0

package/dist/project.js

@@ -1,294 +1,2 @@
-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
+import { a as loadEmailCatalog, d as BRAND_SNAPSHOT_DIR, h as resolveProjectBrand, i as isTemplateDefinition, m as loadBrandEnv, n as createEmailProjectSession, o as readEmailProject, r as exportEmailProject, s as renderEmailFixtures, t as DEFAULT_EXPORT_ASSET_BASE } from "./project-RON2Ei7d.js";
+export { BRAND_SNAPSHOT_DIR, DEFAULT_EXPORT_ASSET_BASE, createEmailProjectSession, exportEmailProject, isTemplateDefinition, loadBrandEnv, loadEmailCatalog, readEmailProject, renderEmailFixtures, resolveProjectBrand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samva/vite",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Unified Vite editor for Samva email, SMS, and WhatsApp templates",
   "keywords": [
     "email",
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@babel/parser": "^8.0.4",
-    "@samva/markup": "^0.7.0",
+    "@samva/markup": "^0.8.0",
     "better-result": "3.0.1",
     "caniemail": "2.0.2",
     "css-tree": "3.2.1",