@samva/markup 0.7.0 → 0.9.0

package/dist/template-_QE_rQND.d.ts

@@ -0,0 +1,65 @@
+import { m as EmailNode } from "./elements-cqldpaJt.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;
+}
+/**
+ * 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;
+/** Caller input for generated references and separate authoring consumers. */
+type TemplateInput<T extends {
+  readonly schema: unknown;
+}> = T["schema"] extends InputSchema<infer Input> ? Input : never;
+/**
+ * The one naming contract for a template `id`: lowercase kebab-case, the same rule as the CLI and
+ * API slug, so the id a definition declares is the handle a caller sends by.
+ */
+declare const TEMPLATE_ID_PATTERN: RegExp;
+/** The email channel of a template: an envelope and a body, each a function of the input. */
+interface EmailChannel<Input> {
+  readonly subject: (input: Input) => string;
+  readonly preheader?: ((input: Input) => string | undefined) | undefined;
+  readonly body: (input: Input) => EmailNode;
+}
+/** A template as `defineTemplate` returns it: its identity, input contract and each channel it declares. */
+interface SmlTemplate<Input> {
+  readonly id: string;
+  readonly schema: InputSchema<Input>;
+  readonly fixtures: Readonly<Record<string, Input>>;
+  readonly locale?: string | undefined;
+  readonly email?: EmailChannel<Input> | undefined;
+  readonly sms?: ((input: Input) => EmailNode) | undefined;
+  readonly whatsapp?: ((input: Input) => EmailNode) | undefined;
+}
+/**
+ * Define a template: one id, one input schema, named fixtures and one body per channel. Every
+ * function in it receives the validated input and returns JSX or a string; a compiler reads them
+ * without running them, so nothing here executes at send time. Types are inferred from the
+ * Standard JSON Schema input.
+ */
+declare const defineTemplate: <S extends StandardJSONSchemaV1>(definition: {
+  readonly id: string;
+  readonly schema: S;
+  readonly fixtures: Readonly<Record<string, NoInfer<StandardJSONSchemaV1.InferInput<S>>>>;
+  readonly locale?: string | undefined;
+  readonly email?: EmailChannel<NoInfer<StandardJSONSchemaV1.InferInput<S>>> | undefined;
+  readonly sms?: ((input: NoInfer<StandardJSONSchemaV1.InferInput<S>>) => EmailNode) | undefined;
+  readonly whatsapp?: ((input: NoInfer<StandardJSONSchemaV1.InferInput<S>>) => EmailNode) | undefined;
+}) => SmlTemplate<StandardJSONSchemaV1.InferInput<S>>;
+//#endregion
+export { TEMPLATE_NAME_PATTERN as a, TEMPLATE_ID_PATTERN as i, EmailContent as n, TemplateInput as o, SmlTemplate as r, defineTemplate as s, EmailChannel as t };
+//# sourceMappingURL=template-_QE_rQND.d.ts.map

package/dist/template.d.ts

@@ -1,2 +1,2 @@
-import { a as TemplateRuntime, i as TemplateInput, n as TEMPLATE_NAME_PATTERN, o as defineEmail, r as TemplateDefinition, s as isTemplateDefinition, t as EmailContent } from "./template-DWftqh4x.js";
-export { EmailContent, TEMPLATE_NAME_PATTERN, TemplateDefinition, TemplateInput, TemplateRuntime, defineEmail, isTemplateDefinition };
+import { a as TEMPLATE_NAME_PATTERN, i as TEMPLATE_ID_PATTERN, n as EmailContent, o as TemplateInput, r as SmlTemplate, s as defineTemplate, t as EmailChannel } from "./template-_QE_rQND.js";
+export { EmailChannel, EmailContent, SmlTemplate, TEMPLATE_ID_PATTERN, TEMPLATE_NAME_PATTERN, TemplateInput, defineTemplate };

package/dist/template.js

@@ -1,8 +1,5 @@
-import { n as isObject } from "./guards-eV1qLbf2.js";
 import { n as inputSchema } from "./input-schema-zjkgrXn2.js";
 //#region src/template.ts
-/** Classify an evaluated module export without executing helpers as templates. */
-const isTemplateDefinition = (value) => isObject(value) && typeof value.id === "string" && typeof value.render === "function" && isObject(value.schema);
 /**
 * The one naming contract for a template id and a fixture key: a letter, a digit or `_` first,
 * then those plus `.`, `_` and `-`.
@@ -19,19 +16,27 @@ const checkTemplateName = (kind, value) => {
 	throw new TypeError(`${kind} ${JSON.stringify(value)} is not one path segment. A template id and a fixture key are written into file paths, so each must start with a letter, a digit or "_" and continue with letters, digits, ".", "_" or "-".`);
 };
 /**
-* 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.
+* The one naming contract for a template `id`: lowercase kebab-case, the same rule as the CLI and
+* API slug, so the id a definition declares is the handle a caller sends by.
 */
-const defineEmail = (definition) => {
-	checkTemplateName("Template id", definition.id);
-	for (const fixture of Object.keys(definition.fixtures)) checkTemplateName("Fixture key", fixture);
+const TEMPLATE_ID_PATTERN = /^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+* Define a template: one id, one input schema, named fixtures and one body per channel. Every
+* function in it receives the validated input and returns JSX or a string; a compiler reads them
+* without running them, so nothing here executes at send time. Types are inferred from the
+* Standard JSON Schema input.
+*/
+const defineTemplate = (definition) => {
+	if (!TEMPLATE_ID_PATTERN.test(definition.id)) throw new TypeError(`Template id ${JSON.stringify(definition.id)} is not lowercase kebab-case. The id is the handle a send names, so write lowercase letters and digits joined by single hyphens, for example "order-shipped".`);
+	const fixtureNames = Object.keys(definition.fixtures);
+	if (fixtureNames.length === 0) throw new TypeError(`Template ${definition.id} declares no fixtures. Fixtures are the preview, the agent's render targets and the publish check; declare at least one.`);
+	for (const fixture of fixtureNames) checkTemplateName("Fixture key", fixture);
 	return {
 		...definition,
 		schema: inputSchema(definition.schema)
 	};
 };
 //#endregion
-export { TEMPLATE_NAME_PATTERN, defineEmail, isTemplateDefinition };
+export { TEMPLATE_ID_PATTERN, TEMPLATE_NAME_PATTERN, defineTemplate };
 
 //# sourceMappingURL=template.js.map