@samva/markup 0.7.0 → 0.9.0

package/dist/template-DWftqh4x.d.ts

@@ -1,60 +0,0 @@
-import { m as EmailNode } from "./elements-BzjjnoCS.js";
-import { r as InputSchema } from "./input-schema-7dPFVvNE.js";
-import { StandardJSONSchemaV1 } from "@standard-schema/spec";
-//#region src/template.d.ts
-/** One actual-input render owns all of a message's authored content. */
-interface EmailContent {
-  readonly subject: string;
-  readonly preheader?: string;
-  readonly body: EmailNode;
-  readonly text?: string;
-}
-/**
- * Fixed ambient values a template declares. Rendering has no clock and no entropy source: reading
- * the current instant or a random value throws unless the matching value is declared here, so a
- * message either takes time and randomness from its input or states them once as configuration.
- */
-interface TemplateRuntime {
-  readonly now?: number;
-  readonly randomSeed?: number;
-}
-/** Explicit template identity distinguishes entries from imported helper modules. */
-interface TemplateDefinition<Input> {
-  readonly id: string;
-  readonly schema: InputSchema<Input>;
-  readonly fixtures: Readonly<Record<string, Input>>;
-  readonly render: (input: Input) => EmailContent;
-  readonly runtime?: TemplateRuntime;
-}
-/** Classify an evaluated module export without executing helpers as templates. */
-declare const isTemplateDefinition: (value: unknown) => value is TemplateDefinition<unknown>;
-/**
- * The one naming contract for a template id and a fixture key: a letter, a digit or `_` first,
- * then those plus `.`, `_` and `-`.
- *
- * Both names are written into file paths — a local export writes one page at
- * `templates/<id>/<fixture>.html` — so each has to be a single plain path segment. The rule lives
- * at the declaration, so a project that could not be exported is refused where the name is
- * written rather than at the end of a build. Consumers that resolve a path from these names
- * import this pattern; they do not restate it.
- */
-declare const TEMPLATE_NAME_PATTERN: RegExp;
-/**
- * Define an email template with caller-input inference from a Standard JSON Schema converter. The
- * helper is named for its channel because its render result is email content; `TemplateDefinition`
- * and `TemplateInput` stay channel-neutral.
- */
-declare const defineEmail: <S extends StandardJSONSchemaV1>(definition: {
-  readonly id: string;
-  readonly schema: S;
-  readonly fixtures: Readonly<Record<string, NoInfer<StandardJSONSchemaV1.InferInput<S>>>>;
-  readonly render: (input: NoInfer<StandardJSONSchemaV1.InferInput<S>>) => EmailContent;
-  readonly runtime?: TemplateRuntime;
-}) => TemplateDefinition<StandardJSONSchemaV1.InferInput<S>>;
-/** Caller input for generated references and separate authoring consumers. */
-type TemplateInput<T extends {
-  readonly render: (input: never) => EmailContent;
-}> = Parameters<T["render"]>[0];
-//#endregion
-export { TemplateRuntime as a, TemplateInput as i, TEMPLATE_NAME_PATTERN as n, defineEmail as o, TemplateDefinition as r, isTemplateDefinition as s, EmailContent as t };
-//# sourceMappingURL=template-DWftqh4x.d.ts.map

package/dist/theme-6ApjjiBo.d.ts

@@ -1,116 +0,0 @@
-//#region src/theme.d.ts
-interface TextToken {
-  readonly sizePx: number;
-  readonly lineHeightPx: number;
-}
-/** One hosted @font-face: the served woff2 src + its weight/style, and the
- *  css2 unicode-range (absent for a whole-file upload). */
-interface FontFace {
-  readonly weight: number;
-  readonly style: "normal" | "italic";
-  readonly src: string;
-  readonly unicodeRange?: string | undefined;
-}
-/** The @font-face set for one font token: the family the rules declare (and that
- *  the token's inline stack leads with) plus its hosted faces. */
-interface FontFaceSet {
-  readonly family: string;
-  readonly faces: ReadonlyArray<FontFace>;
-}
-/**
- * Escape a value interpolated inside a single-quoted CSS string — a
- * `font-family` name or a `url('…')` src. A raw `'` closes the quote early (for
- * a src that also lets a crafted value escape the `url()`), and a raw `\` is read
- * as a CSS escape sequence. `family` and `src` are only min-length-validated
- * upstream, so escaping both keeps every emitted CSS string grammar-safe. Used
- * both here (the inline `font-{name}` stack) and by the compiler's @font-face
- * block, so an escapable family never lands unescaped in either place.
- *
- * The `@font-face` block lives inside a `<style>` element, and an HTML parser
- * scans raw-text elements for the literal `</style>` end tag BEFORE any CSS
- * parsing. So a crafted `family`/`src` containing `</style>` would close the
- * style element and let the remainder render as HTML in the delivered email
- * (a stored-XSS breakout). Rewriting `</` to `<\/` neutralises this: in a
- * quoted CSS string `\/` is identical to `/`, but the HTML tokenizer no longer
- * matches `<\/style>` as a raw-text end tag.
- */
-declare const escapeCssString: (value: string) => string;
-/** A persisted font token: the family the inline stack leads with, the fallback
- *  appended after it, and (for a self-hosted webfont) the hosted faces. The
- *  public compiler owns the single flatten transform for this shape. */
-interface FontToken {
-  readonly family: string;
-  readonly fallback: string;
-  readonly faces?: ReadonlyArray<FontFace> | undefined;
-}
-/**
- * Flatten persisted font tokens into the compiler's two font fields, so the
- * server (apps/api) and the in-browser canvas (apps/web) produce byte-identical
- * output from ONE transform rather than two hand-synced copies:
- *   - `fontFamilies` = the inline stack the `font-{name}` utility emits — the
- *     family quoted (multi-word-safe) then the fallback (which the picker
- *     guarantees ends in a generic, so no client is ever fontless).
- *   - `fontFaces` = the @font-face set for tokens that self-host a webfont.
- * Tokens without `faces` (system stacks) contribute a family but no face set.
- */
-declare const flattenFontTokens: (tokens: Readonly<Record<string, FontToken>>) => {
-  fontFamilies: Record<string, string>;
-  fontFaces: Record<string, FontFaceSet>;
-};
-interface TokenTable {
-  /** Flattened color names ("red-500", "white", "brand") → 6-digit lowercase hex. */
-  readonly colors: Readonly<Record<string, string>>;
-  /**
-   * Dark counterparts, colors namespace only (dark radius/fonts are not a
-   * thing). Only tokens with a dark pair appear; a color-family utility that
-   * resolves a paired token also emits the dark head rule automatically.
-   */
-  readonly colorsDark: Readonly<Record<string, string>>;
-  /** px per spacing unit (`p-4` → 4 × spacingPx). */
-  readonly spacingPx: number;
-  /** text-{size} → font-size / line-height px pair. */
-  readonly text: Readonly<Record<string, TextToken>>;
-  /** leading-{name} → unitless line-height ratio. */
-  readonly leading: Readonly<Record<string, number>>;
-  /** tracking-{name} → letter-spacing em. */
-  readonly trackingEm: Readonly<Record<string, number>>;
-  /** rounded-{name} → border-radius px. */
-  readonly radiusPx: Readonly<Record<string, number>>;
-  /** font-{name} → font-weight number. */
-  readonly fontWeights: Readonly<Record<string, number>>;
-  /** font-{name} → the resolved inline font-family stack (family + fallback,
-   *  guaranteed to end in a generic). */
-  readonly fontFamilies: Readonly<Record<string, string>>;
-  /** font-{name} → its @font-face set, for tokens that self-host a webfont.
-   *  Tokens with no faces (system stacks) are absent. */
-  readonly fontFaces: Readonly<Record<string, FontFaceSet>>;
-  /** max-w-{name} → px. */
-  readonly containerPx: Readonly<Record<string, number>>;
-}
-interface TokenOverrides {
-  readonly colors?: Readonly<Record<string, string>> | undefined;
-  readonly colorsDark?: Readonly<Record<string, string>> | undefined;
-  readonly spacingPx?: number | undefined;
-  readonly text?: Readonly<Record<string, TextToken>> | undefined;
-  readonly leading?: Readonly<Record<string, number>> | undefined;
-  readonly trackingEm?: Readonly<Record<string, number>> | undefined;
-  readonly radiusPx?: Readonly<Record<string, number>> | undefined;
-  readonly fontWeights?: Readonly<Record<string, number>> | undefined;
-  readonly fontFamilies?: Readonly<Record<string, string>> | undefined;
-  readonly fontFaces?: Readonly<Record<string, FontFaceSet>> | undefined;
-  readonly containerPx?: Readonly<Record<string, number>> | undefined;
-}
-interface ThemeLayers {
-  readonly base: TokenTable;
-  /**
-   * Ordered token-override layers, least → most specific (organization →
-   * domain → template). Each is merged onto the running table in turn, so a
-   * later layer's token wins. The caller (the settings cascade in apps/api)
-   * owns assembling this list from the effective design.
-   */
-  readonly overrides?: ReadonlyArray<TokenOverrides> | undefined;
-}
-declare const resolveTokenTable: (layers: ThemeLayers) => TokenTable;
-//#endregion
-export { ThemeLayers as a, escapeCssString as c, TextToken as i, flattenFontTokens as l, FontFaceSet as n, TokenOverrides as o, FontToken as r, TokenTable as s, FontFace as t, resolveTokenTable as u };
-//# sourceMappingURL=theme-6ApjjiBo.d.ts.map

package/dist/theme.d.ts

@@ -1,2 +0,0 @@
-import { a as ThemeLayers, c as escapeCssString, i as TextToken, l as flattenFontTokens, n as FontFaceSet, o as TokenOverrides, r as FontToken, s as TokenTable, t as FontFace, u as resolveTokenTable } from "./theme-6ApjjiBo.js";
-export { FontFace, FontFaceSet, FontToken, TextToken, ThemeLayers, TokenOverrides, TokenTable, escapeCssString, flattenFontTokens, resolveTokenTable };

package/dist/theme.js

@@ -1,118 +0,0 @@
-//#region src/theme.ts
-/**
-* Escape a value interpolated inside a single-quoted CSS string — a
-* `font-family` name or a `url('…')` src. A raw `'` closes the quote early (for
-* a src that also lets a crafted value escape the `url()`), and a raw `\` is read
-* as a CSS escape sequence. `family` and `src` are only min-length-validated
-* upstream, so escaping both keeps every emitted CSS string grammar-safe. Used
-* both here (the inline `font-{name}` stack) and by the compiler's @font-face
-* block, so an escapable family never lands unescaped in either place.
-*
-* The `@font-face` block lives inside a `<style>` element, and an HTML parser
-* scans raw-text elements for the literal `</style>` end tag BEFORE any CSS
-* parsing. So a crafted `family`/`src` containing `</style>` would close the
-* style element and let the remainder render as HTML in the delivered email
-* (a stored-XSS breakout). Rewriting `</` to `<\/` neutralises this: in a
-* quoted CSS string `\/` is identical to `/`, but the HTML tokenizer no longer
-* matches `<\/style>` as a raw-text end tag.
-*/
-const escapeCssString = (value) => value.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/[\u0000-\u001f\u007f]/g, (character) => `\\${character.charCodeAt(0).toString(16)} `).replace(/<\//g, "<\\/");
-const FONT_FAMILY_NAME = /^-?[a-zA-Z][a-zA-Z0-9 -]*$/;
-const SINGLE_QUOTED_FONT_FAMILY = /^'[^'\\<\u0000-\u001f\u007f]*'$/;
-const DOUBLE_QUOTED_FONT_FAMILY = /^"[^"\\<\u0000-\u001f\u007f]*"$/;
-const splitFontStack = (value) => {
-	const families = [];
-	let start = 0;
-	let quote;
-	for (let index = 0; index < value.length; index++) {
-		const character = value[index];
-		if (quote !== void 0) {
-			if (character === quote) quote = void 0;
-		} else if (character === "'" || character === "\"") quote = character;
-		else if (character === ",") {
-			families.push(value.slice(start, index).trim());
-			start = index + 1;
-		}
-	}
-	families.push(value.slice(start).trim());
-	return families;
-};
-const safeFontStack = (value) => {
-	return splitFontStack(value).every((family) => FONT_FAMILY_NAME.test(family) || SINGLE_QUOTED_FONT_FAMILY.test(family) || DOUBLE_QUOTED_FONT_FAMILY.test(family)) ? value : `'${escapeCssString(value)}'`;
-};
-/**
-* Flatten persisted font tokens into the compiler's two font fields, so the
-* server (apps/api) and the in-browser canvas (apps/web) produce byte-identical
-* output from ONE transform rather than two hand-synced copies:
-*   - `fontFamilies` = the inline stack the `font-{name}` utility emits — the
-*     family quoted (multi-word-safe) then the fallback (which the picker
-*     guarantees ends in a generic, so no client is ever fontless).
-*   - `fontFaces` = the @font-face set for tokens that self-host a webfont.
-* Tokens without `faces` (system stacks) contribute a family but no face set.
-*/
-const flattenFontTokens = (tokens) => {
-	const fontFamilies = {};
-	const fontFaces = {};
-	for (const [name, token] of Object.entries(tokens)) {
-		fontFamilies[name] = `'${escapeCssString(token.family)}', ${safeFontStack(token.fallback)}`;
-		if (token.faces != null) fontFaces[name] = {
-			family: token.family,
-			faces: token.faces
-		};
-	}
-	return {
-		fontFamilies,
-		fontFaces
-	};
-};
-const mergeLayer = (table, overrides) => {
-	if (overrides === void 0) return table;
-	return {
-		colors: {
-			...table.colors,
-			...overrides.colors
-		},
-		colorsDark: {
-			...table.colorsDark,
-			...overrides.colorsDark
-		},
-		spacingPx: overrides.spacingPx ?? table.spacingPx,
-		text: {
-			...table.text,
-			...overrides.text
-		},
-		leading: {
-			...table.leading,
-			...overrides.leading
-		},
-		trackingEm: {
-			...table.trackingEm,
-			...overrides.trackingEm
-		},
-		radiusPx: {
-			...table.radiusPx,
-			...overrides.radiusPx
-		},
-		fontWeights: {
-			...table.fontWeights,
-			...overrides.fontWeights
-		},
-		fontFamilies: {
-			...table.fontFamilies,
-			...overrides.fontFamilies
-		},
-		fontFaces: {
-			...table.fontFaces,
-			...overrides.fontFaces
-		},
-		containerPx: {
-			...table.containerPx,
-			...overrides.containerPx
-		}
-	};
-};
-const resolveTokenTable = (layers) => (layers.overrides ?? []).reduce(mergeLayer, layers.base);
-//#endregion
-export { escapeCssString, flattenFontTokens, resolveTokenTable };
-
-//# sourceMappingURL=theme.js.map

package/dist/tokens.d.ts

@@ -1,6 +0,0 @@
-import { s as TokenTable } from "./theme-6ApjjiBo.js";
-//#region src/tokens.d.ts
-declare const baseTokens: TokenTable;
-//#endregion
-export { baseTokens };
-//# sourceMappingURL=tokens.d.ts.map