@samva/markup 0.7.0 → 0.9.0

package/dist/transform-Ct2OMkFN.d.ts

@@ -0,0 +1,153 @@
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { n as EmittedPosition } from "./preview-Ekdg1dXG.js";
+import { i as Stylesheet } from "./css-BVQKICKC.js";
+import { n as AssetEntry } from "./assets-C5duwTya.js";
+import { a as EmailBrand } from "./brand-B-0bN_Ir.js";
+import { caniemail } from "caniemail";
+//#region src/email/compatibility.d.ts
+type CaniemailClient = Parameters<typeof caniemail>[0]["clients"][number];
+/** One client this compiler makes claims about. */
+interface EmailClientTarget {
+  readonly id: CaniemailClient;
+  readonly label: string;
+}
+/**
+ * The pinned matrix. Every finding is reported per client, and a client absent
+ * from this list is a client Samva makes no claim about.
+ */
+declare const EMAIL_CLIENT_MATRIX: readonly EmailClientTarget[];
+interface CompatibilityProvenance {
+  /** The exact rules package a finding came from. */
+  readonly rules: string;
+  readonly apiVersion: string;
+  /** The day caniemail last changed the data this build was checked against. */
+  readonly lastUpdate: string;
+}
+declare const COMPATIBILITY_PROVENANCE: CompatibilityProvenance;
+/**
+ * The constructs whose loss actually breaks a message: the recipient reads
+ * something different, in a different order, follows a link that does not work,
+ * or sees a layout that has collapsed. A target client dropping one of these
+ * blocks publication.
+ *
+ * The list is deliberately short and enumerated, because the contract is to
+ * block *known* failures. Nonessential differences require an assessment of
+ * emitted values: a concrete risk warns, expected differences and unverified
+ * behavior remain compatibility observations.
+ */
+declare const ESSENTIAL_CONSTRUCTS: ReadonlySet<string>;
+interface CompatibilityInput {
+  /** The document the recipient receives. */
+  readonly html: string;
+  /** The declared fixture checked by this invocation. */
+  readonly fixture?: string | undefined;
+  /** Retained head rules, when they are not already inside the HTML. */
+  readonly css?: string | undefined;
+  /** Emitted-offset ranges with the origins of the node that produced them. */
+  readonly positions?: readonly EmittedPosition[] | undefined;
+  readonly clients?: readonly EmailClientTarget[] | undefined;
+}
+/**
+ * Check the emitted document against the pinned matrix.
+ *
+ * Findings are grouped by construct rather than repeated per client, so one
+ * unsupported property is one diagnostic naming every client that drops it.
+ */
+declare const checkEmailCompatibility: (input: CompatibilityInput) => readonly EmailDiagnostic[];
+/**
+ * Constructs the pinned data says nothing about for a target client. These are
+ * reported so "we did not check that" is never mistaken for "that works".
+ */
+declare const unknownCoverage: (titles: Iterable<string>) => readonly EmailDiagnostic[];
+/** A publication carrying one of these is refused; the message would arrive broken. */
+declare const hasBlockingCompatibility: (findings: readonly EmailDiagnostic[]) => boolean;
+//#endregion
+//#region src/email/tailwind.d.ts
+interface TailwindOptions {
+  /**
+   * Project CSS appended to the compiled entry: `@theme` overrides, `@utility`
+   * definitions and ordinary rules. This is the project's pinned configuration.
+   */
+  readonly css?: string | undefined;
+  /**
+   * The project path `css` was read from (`theme.css` by default). Its
+   * relative `@import`s resolve from this file's directory.
+   */
+  readonly cssPath?: string | undefined;
+  /** Classes the compiler cannot discover, declared by the project on purpose. */
+  readonly safelist?: readonly string[] | undefined;
+  /** Tailwind's browser reset is off by default; email clients do not want it. */
+  readonly preflight?: boolean | undefined;
+  /**
+   * Bounds on what the compiler may generate. Class discovery reads authored
+   * source, so a project can hand it an unbounded candidate set and get an
+   * unbounded stylesheet back — inside a build that has a wall clock and a
+   * bundle a Worker then has to load. A host that publishes supplies these.
+   */
+  readonly limits?: TailwindLimits | undefined;
+}
+interface TailwindLimits {
+  /** Distinct classes handed to the compiler. */
+  readonly candidates: number;
+  /** Bytes of generated CSS. */
+  readonly cssBytes: number;
+}
+interface TailwindOutput {
+  readonly css: string;
+  readonly version: string;
+  /** Every candidate handed to the compiler, sorted, for the build manifest. */
+  readonly candidates: readonly string[];
+}
+/**
+ * What the project theme's `@import`s resolve to, already checked by
+ * `resolveThemeImports`: project stylesheets by path, and the brand theme
+ * `samva:brand` stands for.
+ */
+interface TailwindImports {
+  readonly stylesheets: ReadonlyMap<string, string>;
+  readonly brandCss?: string | undefined;
+}
+/** Compile the discovered class set into CSS with the pinned Tailwind release. */
+declare const compileTailwind: (candidates: Iterable<string>, options?: TailwindOptions, imports?: TailwindImports) => Promise<TailwindOutput>;
+interface ClassDiscovery {
+  readonly candidates: readonly string[];
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * Collect the class names one module states literally, and report the positions
+ * where a class is assembled from values the compiler cannot see.
+ */
+declare const discoverClassCandidates: (source: string, fileName: string) => ClassDiscovery;
+//#endregion
+//#region src/email/transform.d.ts
+/** Where this build serves assets from, and how Tailwind is configured. */
+interface TransformOptions {
+  readonly assetBase: string;
+  /** `false` compiles no Tailwind at all. */
+  readonly tailwind?: TailwindOptions | false | undefined;
+  /**
+   * The brand `samva:brand` resolves to, supplied by the host. A project that
+   * imports `samva:brand` with no brand here fails to compile.
+   */
+  readonly brand?: EmailBrand | undefined;
+}
+interface ProjectTransform {
+  readonly assets: readonly AssetEntry[];
+  /** The compiled Tailwind sheet, when the project used any utility class. */
+  readonly tailwindSheet: Stylesheet | undefined;
+  /** Every project stylesheet, parsed, by path. */
+  readonly stylesheets: ReadonlyMap<string, Stylesheet>;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * The `samva:brand` specifier a project imports — from its theme's `@import`s
+ * or its TSX — so a host can fetch that brand before it compiles. `undefined`
+ * when the project imports no brand. A project that names two brands gets the
+ * first here and a refusal from the compile.
+ */
+declare const projectBrandSpecifier: (files: Readonly<Record<string, string | Uint8Array>>, themePath?: string) => string | undefined;
+/** Read a whole project, then compile the classes its scripts used. */
+declare const transformProject: (files: Readonly<Record<string, string | Uint8Array>>, options: TransformOptions) => Promise<ProjectTransform>;
+//#endregion
+export { checkEmailCompatibility as _, ClassDiscovery as a, TailwindOutput as c, COMPATIBILITY_PROVENANCE as d, CompatibilityInput as f, EmailClientTarget as g, ESSENTIAL_CONSTRUCTS as h, transformProject as i, compileTailwind as l, EMAIL_CLIENT_MATRIX as m, TransformOptions as n, TailwindLimits as o, CompatibilityProvenance as p, projectBrandSpecifier as r, TailwindOptions as s, ProjectTransform as t, discoverClassCandidates as u, hasBlockingCompatibility as v, unknownCoverage as y };
+//# sourceMappingURL=transform-Ct2OMkFN.d.ts.map

package/dist/unsubscribe-link-CoesnQDU.js

@@ -0,0 +1,26 @@
+//#region src/internal/unsubscribe-link.ts
+/**
+* Marks the one link the serializer lets carry the unsubscribe placeholder as
+* its href. Only `BrandFooter` sets it; nothing public exports it, so no
+* author-written link can claim the exemption.
+*/
+const UNSUBSCRIBE_LINK = Symbol("samva.unsubscribe-link");
+/**
+* The per-recipient unsubscribe URL is not known at render: the send path
+* substitutes each delivery's link for this placeholder, or removes the
+* unsubscribe row when the send resolved no unsubscribe group.
+*/
+const UNSUBSCRIBE_URL_PLACEHOLDER = "%samva:unsubscribe-url%";
+/**
+* Marks the elements `BrandFooter` writes the send path's footer markers on.
+* The serializer emits `data-samva-footer` and `data-samva-unsubscribe` only
+* for an element carrying it, so an author cannot claim a footer the send
+* path would then not append.
+*/
+const BRAND_FOOTER_MARKER = Symbol("samva.brand-footer-marker");
+/** The attributes only `BrandFooter` writes. */
+const RESERVED_FOOTER_ATTRIBUTES = /* @__PURE__ */ new Set(["data-samva-footer", "data-samva-unsubscribe"]);
+//#endregion
+export { UNSUBSCRIBE_URL_PLACEHOLDER as i, RESERVED_FOOTER_ATTRIBUTES as n, UNSUBSCRIBE_LINK as r, BRAND_FOOTER_MARKER as t };
+
+//# sourceMappingURL=unsubscribe-link-CoesnQDU.js.map

package/dist/whatsapp.d.ts

@@ -0,0 +1,57 @@
+import { n as WhatsAppCategory, r as WhatsAppHeaderType } from "./channel-specs-C2feJwuP.js";
+import { f as EmailChild, m as EmailNode } from "./elements-cqldpaJt.js";
+//#region src/whatsapp.d.ts
+interface WhatsAppProps {
+  readonly name?: string | undefined;
+  /** The Meta language code, for example `en_US`. */
+  readonly language: string;
+  readonly category: WhatsAppCategory;
+  readonly children?: EmailChild;
+}
+interface WhatsAppHeaderProps {
+  /** `text` by default; for `image`, `video` and `document` the child is the media URL. */
+  readonly type?: WhatsAppHeaderType | undefined;
+  readonly children?: EmailChild;
+}
+interface WhatsAppTextProps {
+  readonly children?: EmailChild;
+}
+interface WhatsAppButtonsProps {
+  readonly children?: EmailChild;
+}
+interface WhatsAppUrlButtonProps {
+  readonly url: string;
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppPhoneButtonProps {
+  readonly phone: string;
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppQuickReplyButtonProps {
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppCopyCodeButtonProps {
+  /** The code the button copies. */
+  readonly children?: EmailChild;
+}
+/**
+ * The root of a WhatsApp body. Meta's template anatomy is the vocabulary: `WhatsApp.Header`,
+ * `WhatsApp.Body`, `WhatsApp.Footer` and `WhatsApp.Buttons`, whose children are the four button
+ * kinds.
+ */
+declare const WhatsApp: ((props: WhatsAppProps) => EmailNode) & {
+  Header: (props: WhatsAppHeaderProps) => EmailNode;
+  Body: (props: WhatsAppTextProps) => EmailNode;
+  Footer: (props: WhatsAppTextProps) => EmailNode;
+  Buttons: (props: WhatsAppButtonsProps) => EmailNode;
+  UrlButton: (props: WhatsAppUrlButtonProps) => EmailNode;
+  QuickReplyButton: (props: WhatsAppQuickReplyButtonProps) => EmailNode;
+  PhoneButton: (props: WhatsAppPhoneButtonProps) => EmailNode;
+  CopyCodeButton: (props: WhatsAppCopyCodeButtonProps) => EmailNode;
+};
+//#endregion
+export { WhatsApp, WhatsAppButtonsProps, type WhatsAppCategory, WhatsAppCopyCodeButtonProps, WhatsAppHeaderProps, type WhatsAppHeaderType, WhatsAppPhoneButtonProps, WhatsAppProps, WhatsAppQuickReplyButtonProps, WhatsAppTextProps, WhatsAppUrlButtonProps };
+//# sourceMappingURL=whatsapp.d.ts.map

package/dist/whatsapp.js

@@ -0,0 +1,22 @@
+import { Fragment, jsx } from "./email/jsx-runtime.js";
+//#region src/whatsapp.ts
+const fragment = (children) => jsx(Fragment, { children });
+/**
+* The root of a WhatsApp body. Meta's template anatomy is the vocabulary: `WhatsApp.Header`,
+* `WhatsApp.Body`, `WhatsApp.Footer` and `WhatsApp.Buttons`, whose children are the four button
+* kinds.
+*/
+const WhatsApp = Object.assign((props) => fragment(props.children), {
+	Header: (props) => fragment(props.children),
+	Body: (props) => fragment(props.children),
+	Footer: (props) => fragment(props.children),
+	Buttons: (props) => fragment(props.children),
+	UrlButton: (props) => fragment(props.children),
+	QuickReplyButton: (props) => fragment(props.children),
+	PhoneButton: (props) => fragment(props.children),
+	CopyCodeButton: (props) => fragment(props.children)
+});
+//#endregion
+export { WhatsApp };
+
+//# sourceMappingURL=whatsapp.js.map