@samva/markup 0.8.0 → 0.9.0

package/dist/static.d.ts

@@ -0,0 +1,57 @@
+import { a as TemplateDiagnostic, r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { E as TemplateIr } from "./ir-aaqNE987.js";
+import { g as EmailClientTarget, n as TransformOptions } from "./transform-Ct2OMkFN.js";
+import "./css-BVQKICKC.js";
+import { n as AssetEntry } from "./assets-C5duwTya.js";
+//#region src/sml/lower-project.d.ts
+interface CompiledTemplate {
+  /** The IR, or `undefined` when a finding blocks it. */
+  readonly ir: TemplateIr | undefined;
+  /** The fixtures read from the entry, with imported assets resolved to their URLs. */
+  readonly fixtures: Readonly<Record<string, unknown>>;
+  readonly assets: readonly AssetEntry[];
+  /** Errors block the IR; warnings ride along. */
+  readonly diagnostics: readonly TemplateDiagnostic[];
+}
+//#endregion
+//#region src/sml/compile.d.ts
+interface CompileTemplateOptions extends TransformOptions {
+  /** The project's files by path. Binary files are addressed as assets. */
+  readonly files: Readonly<Record<string, string | Uint8Array>>;
+  /** The entry: a `.tsx` file that default-exports `defineTemplate({ ... })`. */
+  readonly entry: string;
+  /**
+   * The portable JSON Schema, for an entry whose `schema` is not a literal `jsonSchema(...)`
+   * (a Zod or Effect schema needs a library to become JSON Schema). A host that has evaluated the
+   * schema passes its conversion here; a literal schema is read from source and this is ignored.
+   */
+  readonly schema?: Readonly<Record<string, unknown>> | undefined;
+}
+/** Compile a project's entry template to IR without evaluating any of it. */
+declare const compileTemplate: (options: CompileTemplateOptions) => Promise<CompiledTemplate>;
+//#endregion
+//#region src/sml/compatibility.d.ts
+/**
+ * Check what each declared fixture delivers against the pinned client matrix. The rules run on the
+ * rendered document, because what a client drops is what the compiler produced, and every finding
+ * is located at the source of the element that produced it.
+ */
+declare const checkTemplateCompatibility: (ir: TemplateIr, fixtures: Readonly<Record<string, unknown>>, options?: {
+  readonly clients?: readonly EmailClientTarget[] | undefined;
+}) => readonly EmailDiagnostic[];
+//#endregion
+//#region src/sml/profile.d.ts
+/**
+ * Check an entry against the static profile. Pass the entry's source alone, or the project's files
+ * and the entry's path. Imports of files that are absent are trusted to exist, and the brand,
+ * Tailwind and theme are not resolved, so the result holds only findings the source itself owns.
+ */
+declare const checkStaticProfile: (files: string | Readonly<Record<string, string | Uint8Array>>, entry?: string) => readonly TemplateDiagnostic[];
+/**
+ * The errors in `after` that `before` did not already have, compared by code and message so a
+ * finding that only moved does not count as new.
+ */
+declare const introducedProfileErrors: (before: readonly TemplateDiagnostic[], after: readonly TemplateDiagnostic[]) => readonly TemplateDiagnostic[];
+//#endregion
+export { type CompileTemplateOptions, type CompiledTemplate, checkStaticProfile, checkTemplateCompatibility, compileTemplate, introducedProfileErrors };
+//# sourceMappingURL=static.d.ts.map

package/dist/static.js

@@ -0,0 +1,69 @@
+import { assetUrl } from "./email/assets.js";
+import { EmailCompileError } from "./email/diagnostics.js";
+import { c as transformProject, i as checkEmailCompatibility } from "./compatibility-DbISoFIq.js";
+import { a as lowerProject, i as completed, n as introducedProfileErrors, o as Findings, r as loadProject, t as checkStaticProfile } from "./profile-BH-OtdDA.js";
+import { renderIr } from "./render-ir.js";
+//#region src/sml/compile.ts
+/** Compile a project's entry template to IR without evaluating any of it. */
+const compileTemplate = async (options) => {
+	const findings = new Findings();
+	const project = loadProject(options.files, options.entry, findings);
+	if (project === void 0) return completed(findings, void 0);
+	let transformed;
+	try {
+		transformed = await transformProject(options.files, options);
+	} catch (error) {
+		if (!(error instanceof EmailCompileError)) throw error;
+		findings.items.push(...error.diagnostics);
+		return completed(findings, void 0);
+	}
+	findings.items.push(...transformed.diagnostics.filter((item) => item.code !== "tailwind-dynamic-class"));
+	const assetsByPath = new Map(transformed.assets.map((asset) => [asset.path, asset]));
+	return lowerProject(options, project, findings, {
+		assets: transformed.assets,
+		stylesheets: transformed.stylesheets,
+		tailwindSheet: transformed.tailwindSheet,
+		urlFor: (path) => {
+			const entry = assetsByPath.get(path);
+			return entry === void 0 ? void 0 : assetUrl(entry, options.assetBase);
+		}
+	});
+};
+//#endregion
+//#region src/sml/compatibility.ts
+/**
+* Check what each declared fixture delivers against the pinned client matrix. The rules run on the
+* rendered document, because what a client drops is what the compiler produced, and every finding
+* is located at the source of the element that produced it.
+*/
+const checkTemplateCompatibility = (ir, fixtures, options = {}) => {
+	if (ir.email === void 0) return [];
+	const sources = ir.sources ?? [];
+	const findings = [];
+	for (const [fixture, input] of Object.entries(fixtures)) {
+		const rendered = renderIr(ir, input, { positions: true });
+		const positions = (rendered.positions ?? []).map((position, index) => ({
+			start: position.start,
+			end: position.end,
+			tag: position.tag,
+			instancePath: String(index),
+			authored: true,
+			origins: position.src === void 0 ? [] : [{
+				fileName: sources[position.src[2] ?? 0] ?? "",
+				lineNumber: position.src[0],
+				columnNumber: position.src[1]
+			}]
+		}));
+		findings.push(...checkEmailCompatibility({
+			html: rendered.html,
+			fixture,
+			positions,
+			...options.clients === void 0 ? {} : { clients: options.clients }
+		}));
+	}
+	return findings;
+};
+//#endregion
+export { checkStaticProfile, checkTemplateCompatibility, compileTemplate, introducedProfileErrors };
+
+//# sourceMappingURL=static.js.map