@frigear-nu/forms 0.0.0-stage → 0.0.2

package/dist/runtime/server/utils/submit.js

@@ -0,0 +1,120 @@
+import { eq } from "drizzle-orm";
+import { db, schema } from "@nuxthub/db";
+import { blob } from "@nuxthub/blob";
+import { buildFormSchema, newId, validatedFields } from "../../utils/index.js";
+const safeFilename = (name) => name.replace(/[^\w.-]+/g, "_").replace(/^\.+/, "").slice(0, 120) || "file";
+async function readSubmission(event) {
+  const uploads = /* @__PURE__ */ new Map();
+  const contentType = getRequestHeader(event, "content-type") ?? "";
+  if (contentType.includes("multipart/form-data")) {
+    const parts = await readMultipartFormData(event) ?? [];
+    let answers = {};
+    let locale = "en";
+    for (const part of parts) {
+      if (part.name === "answers") {
+        try {
+          answers = JSON.parse(part.data.toString("utf8"));
+        } catch {
+          throw createError({ statusCode: 400, statusMessage: "Invalid answers." });
+        }
+      } else if (part.name === "locale") {
+        locale = part.data.toString("utf8").slice(0, 20);
+      } else if (part.name?.startsWith("file:") && part.filename) {
+        const key = part.name.slice(5);
+        uploads.set(key, [...uploads.get(key) ?? [], { filename: part.filename, type: part.type ?? "application/octet-stream", data: part.data }]);
+      }
+    }
+    return { answers, locale, uploads };
+  }
+  const body = await readBody(event);
+  return { answers: body?.answers ?? {}, locale: String(body?.locale ?? "en").slice(0, 20), uploads };
+}
+export async function processSubmission(event, form, userId) {
+  const definition = form.definition;
+  const { answers: raw, locale, uploads } = await readSubmission(event);
+  const answers = { ...raw };
+  for (const field of validatedFields(definition, raw)) {
+    if (field.type !== "file") continue;
+    const files2 = uploads.get(field.key) ?? [];
+    answers[field.key] = files2.map((file) => ({ name: file.filename, size: file.data.byteLength, type: file.type }));
+  }
+  const parsed = buildFormSchema(definition, answers, { locale }).safeParse(answers);
+  if (!parsed.success) {
+    throw createError({
+      statusCode: 422,
+      statusMessage: "Invalid submission.",
+      data: { issues: parsed.error.issues.map((issue) => ({ path: issue.path, message: issue.message })) }
+    });
+  }
+  const validated = parsed.data;
+  const stored = definition.storage !== "none";
+  const submissionId = stored ? newId("fsb") : null;
+  const files = [];
+  if (stored) {
+    for (const field of validatedFields(definition, answers)) {
+      if (field.type !== "file") continue;
+      for (const upload of uploads.get(field.key) ?? []) {
+        const saved = await blob.put(safeFilename(upload.filename), upload.data, {
+          contentType: upload.type,
+          prefix: `forms/${form.slug}/${submissionId}/${field.key}`,
+          addRandomSuffix: true
+        });
+        files.push({ fieldKey: field.key, filename: upload.filename, contentType: upload.type, size: upload.data.byteLength, pathname: saved.pathname });
+      }
+    }
+    await db.insert(schema.formSubmissions).values({
+      id: submissionId,
+      formId: form.id,
+      formSlug: form.slug,
+      formVersion: form.version,
+      definitionSnapshot: definition,
+      answers: validated,
+      userId,
+      locale,
+      deliveryStatus: "pending"
+    });
+    if (files.length) {
+      await db.insert(schema.formSubmissionFiles).values(files.map((file) => ({
+        id: newId("fsf"),
+        submissionId,
+        fieldKey: file.fieldKey,
+        pathname: file.pathname,
+        filename: file.filename,
+        contentType: file.contentType,
+        size: file.size
+      })));
+    }
+  }
+  const ctx = {
+    event,
+    form: { id: form.id, slug: form.slug, name: form.name, version: form.version, definition },
+    answers: validated,
+    files,
+    locale,
+    userId,
+    submissionId,
+    stored,
+    delivered: false
+  };
+  const hooks = useNitroApp().hooks;
+  let error;
+  try {
+    await hooks.callHook("forms:submitted", ctx);
+  } catch (cause) {
+    error = cause instanceof Error ? cause.message : String(cause);
+    console.error(`[forms] delivery of "${form.slug}" failed:`, cause);
+  }
+  if (stored) {
+    await db.update(schema.formSubmissions).set({
+      deliveryStatus: error ? "failed" : ctx.delivered ? "delivered" : "none",
+      deliveryError: error ?? null
+    }).where(eq(schema.formSubmissions.id, submissionId));
+  } else if (error) {
+    throw createError({ statusCode: 502, statusMessage: "The submission could not be delivered." });
+  }
+  if (ctx.delivered || error) {
+    const result = { submissionId, formSlug: form.slug, status: error ? "failed" : "delivered", error };
+    await hooks.callHook("forms:delivered", result);
+  }
+  return { ok: true, id: submissionId };
+}

package/dist/runtime/utils/conditions.d.ts

@@ -0,0 +1,19 @@
+import type { Condition, FormDefinition, FormField, FormStep } from '../../types.js';
+export type Answers = Record<string, unknown>;
+/** Evaluates a `showIf` condition against the answers of the currently visible fields. */
+export declare function evaluateCondition(condition: Condition | undefined, answers: Answers): boolean;
+export type VisibleStep = {
+    step: FormStep;
+    index: number;
+    fields: FormField[];
+};
+/**
+ * Resolves which steps and fields are visible for the given answers. Fields are walked in
+ * definition order and a condition only sees answers of fields that are themselves visible, so a
+ * hidden field's stale answer can never keep another field shown. A condition on a field that
+ * comes later in the form therefore never matches.
+ */
+export declare function resolveVisibility(definition: FormDefinition, answers: Answers): VisibleStep[];
+export declare function isFieldVisible(definition: FormDefinition, key: string, answers: Answers): boolean;
+/** Fields that collect an answer (everything except static `markdown`). */
+export declare const isInputField: (field: FormField) => boolean;

package/dist/runtime/utils/conditions.js

@@ -0,0 +1,36 @@
+const isEmpty = (value) => value === void 0 || value === null || value === "" || value === false || Array.isArray(value) && value.length === 0;
+export function evaluateCondition(condition, answers) {
+  if (!condition) return true;
+  const answer = answers[condition.field];
+  switch (condition.op) {
+    case "truthy":
+      return !isEmpty(answer);
+    case "eq":
+      return answer === condition.value;
+    case "neq":
+      return answer !== condition.value;
+    case "in":
+      return Array.isArray(condition.value) && condition.value.includes(answer);
+    default:
+      return true;
+  }
+}
+export function resolveVisibility(definition, answers) {
+  const effective = {};
+  const result = [];
+  definition.steps.forEach((step, index) => {
+    if (!evaluateCondition(step.showIf, effective)) return;
+    const fields = [];
+    for (const field of step.fields) {
+      if (!evaluateCondition(field.showIf, effective)) continue;
+      fields.push(field);
+      if (field.key in answers) effective[field.key] = answers[field.key];
+    }
+    result.push({ step, index, fields });
+  });
+  return result;
+}
+export function isFieldVisible(definition, key, answers) {
+  return resolveVisibility(definition, answers).some(({ fields }) => fields.some((field) => field.key === key));
+}
+export const isInputField = (field) => field.type !== "markdown";

package/dist/runtime/utils/definition.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import type { FormDefinition } from '../../types.js';
+export declare const formDefinitionSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        single: "single";
+        stepped: "stepped";
+    }>;
+    storage: z.ZodDefault<z.ZodEnum<{
+        db: "db";
+        none: "none";
+    }>>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        showIf: z.ZodOptional<z.ZodObject<{
+            field: z.ZodString;
+            op: z.ZodEnum<{
+                eq: "eq";
+                neq: "neq";
+                in: "in";
+                truthy: "truthy";
+            }>;
+            value: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>>;
+        fields: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodEnum<{
+                number: "number";
+                text: "text";
+                email: "email";
+                tel: "tel";
+                textarea: "textarea";
+                select: "select";
+                radio: "radio";
+                checkbox: "checkbox";
+                date: "date";
+                file: "file";
+                markdown: "markdown";
+            }>;
+            content: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            placeholder: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            required: z.ZodOptional<z.ZodBoolean>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>;
+            }, z.core.$strip>>>;
+            multiple: z.ZodOptional<z.ZodBoolean>;
+            autocomplete: z.ZodOptional<z.ZodString>;
+            validation: z.ZodOptional<z.ZodObject<{
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                minLength: z.ZodOptional<z.ZodNumber>;
+                maxLength: z.ZodOptional<z.ZodNumber>;
+                pattern: z.ZodOptional<z.ZodString>;
+                maxFiles: z.ZodOptional<z.ZodNumber>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            }, z.core.$strip>>;
+            showIf: z.ZodOptional<z.ZodObject<{
+                field: z.ZodString;
+                op: z.ZodEnum<{
+                    eq: "eq";
+                    neq: "neq";
+                    in: "in";
+                    truthy: "truthy";
+                }>;
+                value: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    submit: z.ZodOptional<z.ZodObject<{
+        label: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        successMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        redirect: z.ZodOptional<z.ZodString>;
+        allowResubmit: z.ZodOptional<z.ZodObject<{
+            keep: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    delivery: z.ZodOptional<z.ZodObject<{
+        email: z.ZodOptional<z.ZodObject<{
+            to: z.ZodArray<z.ZodString>;
+            subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FormDefinitionInput = z.input<typeof formDefinitionSchema>;
+export declare function parseFormDefinition(input: unknown): FormDefinition;

package/dist/runtime/utils/definition.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+const translated = z.union([z.string(), z.record(z.string(), z.string())]);
+const KEY = /^[a-z]\w*$/i;
+const ID = /^[a-z0-9][\w-]*$/i;
+const condition = z.object({
+  field: z.string().regex(KEY),
+  op: z.enum(["eq", "neq", "in", "truthy"]),
+  value: z.unknown().optional()
+});
+const field = z.object({
+  key: z.string().regex(KEY, "Field keys must start with a letter and contain only letters, digits and underscores."),
+  type: z.enum(["text", "email", "tel", "number", "textarea", "select", "radio", "checkbox", "date", "file", "markdown"]),
+  content: translated.optional(),
+  label: translated.optional(),
+  description: translated.optional(),
+  placeholder: translated.optional(),
+  required: z.boolean().optional(),
+  options: z.array(z.object({ value: z.string().min(1), label: translated })).optional(),
+  multiple: z.boolean().optional(),
+  autocomplete: z.string().max(40).optional(),
+  validation: z.object({
+    min: z.number().optional(),
+    max: z.number().optional(),
+    minLength: z.number().int().min(0).optional(),
+    maxLength: z.number().int().min(1).optional(),
+    pattern: z.string().max(500).optional(),
+    maxFiles: z.number().int().min(1).max(50).optional(),
+    maxSize: z.number().int().min(1).optional(),
+    accept: z.array(z.string()).optional(),
+    message: translated.optional()
+  }).optional(),
+  showIf: condition.optional()
+});
+const step = z.object({
+  id: z.string().regex(ID),
+  title: translated.optional(),
+  description: translated.optional(),
+  showIf: condition.optional(),
+  fields: z.array(field)
+});
+const sameOriginPath = (value) => value.startsWith("/") && !value.startsWith("//") && !value.startsWith("/\\");
+const emailAddress = z.string().regex(/^[^\s@${}]+@[^\s$@{}][^\s$.@{}]*\.[^\s$@{}]+$/, "Recipients must be plain email addresses.");
+export const formDefinitionSchema = z.object({
+  mode: z.enum(["single", "stepped"]),
+  storage: z.enum(["db", "none"]).default("db"),
+  steps: z.array(step).min(1),
+  submit: z.object({
+    label: translated.optional(),
+    successMessage: translated.optional(),
+    redirect: z.string().refine(sameOriginPath, "Redirect must be a path on this site.").optional(),
+    allowResubmit: z.object({ keep: z.array(z.string()) }).optional()
+  }).optional(),
+  delivery: z.object({
+    email: z.object({ to: z.array(emailAddress).min(1), subject: translated.optional() }).optional()
+  }).optional()
+}).superRefine((definition, ctx) => {
+  const fail = (message, path) => ctx.addIssue({ code: "custom", message, path });
+  if (definition.mode === "single" && definition.steps.length !== 1) {
+    fail("A single page form has exactly one step.", ["steps"]);
+  }
+  const stepIds = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Map();
+  definition.steps.forEach((s, stepIndex) => {
+    if (stepIds.has(s.id)) fail(`Duplicate step id "${s.id}".`, ["steps", stepIndex, "id"]);
+    stepIds.add(s.id);
+    s.fields.forEach((f, fieldIndex) => {
+      const path = ["steps", stepIndex, "fields", fieldIndex];
+      if (keys.has(f.key)) fail(`Duplicate field key "${f.key}".`, [...path, "key"]);
+      keys.set(f.key, f.type);
+      if ((f.type === "select" || f.type === "radio") && !f.options?.length) {
+        fail("Select and radio fields need options.", [...path, "options"]);
+      }
+      if (f.type === "markdown" && !f.content) fail("Markdown fields need content.", [...path, "content"]);
+      if (f.type === "file" && definition.storage === "none") {
+        fail('File fields need a form that stores submissions (storage "db").', [...path, "type"]);
+      }
+      if (f.validation?.pattern) {
+        try {
+          new RegExp(f.validation.pattern);
+        } catch {
+          fail("Invalid regular expression.", [...path, "validation", "pattern"]);
+        }
+      }
+    });
+  });
+  const seen = /* @__PURE__ */ new Set();
+  definition.steps.forEach((s, stepIndex) => {
+    const check = (cond, path) => {
+      if (cond && !seen.has(cond.field)) fail(`Condition refers to unknown or later field "${cond.field}".`, path);
+    };
+    check(s.showIf, ["steps", stepIndex, "showIf", "field"]);
+    s.fields.forEach((f, fieldIndex) => {
+      check(f.showIf, ["steps", stepIndex, "fields", fieldIndex, "showIf", "field"]);
+      if (f.type !== "markdown") seen.add(f.key);
+    });
+  });
+  definition.submit?.allowResubmit?.keep.forEach((key, index) => {
+    if (!keys.has(key)) fail(`Unknown field "${key}".`, ["submit", "allowResubmit", "keep", index]);
+  });
+});
+export function parseFormDefinition(input) {
+  return formDefinitionSchema.parse(input);
+}

package/dist/runtime/utils/index.d.ts

@@ -0,0 +1,13 @@
+import type { FormDefinition } from '../../types.js';
+export type * from '../../types';
+export { translate, interpolate, defaultMessages, newId } from './text.js';
+export type { MessageTranslator, TranslateParams } from './text.js';
+export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField } from './conditions.js';
+export type { Answers, VisibleStep } from './conditions.js';
+export { buildFormSchema, buildFieldSchema, validatedFields } from './schema.js';
+export type { SchemaOptions } from './schema.js';
+export { formDefinitionSchema, parseFormDefinition } from './definition.js';
+export type { FormDefinitionInput } from './definition.js';
+/** Typed identity helper for authoring definitions (seed files, tests). */
+export declare function defineForm<const T extends FormDefinition>(definition: T): T;
+export { renderMarkdown } from './markdown.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,8 @@
+export { translate, interpolate, defaultMessages, newId } from "./text.js";
+export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField } from "./conditions.js";
+export { buildFormSchema, buildFieldSchema, validatedFields } from "./schema.js";
+export { formDefinitionSchema, parseFormDefinition } from "./definition.js";
+export function defineForm(definition) {
+  return definition;
+}
+export { renderMarkdown } from "./markdown.js";

package/dist/runtime/utils/markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tiny, safe renderer for `markdown` fields: escapes everything, then supports `**bold**`,
+ * `_italic_`, `[text](https://…)` links and blank-line separated paragraphs.
+ */
+export declare function renderMarkdown(source: string): string;

package/dist/runtime/utils/markdown.js

@@ -0,0 +1,5 @@
+const escape = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const safeHref = (href) => /^(?:https?:\/\/|\/(?![/\\])|mailto:)/.test(href);
+export function renderMarkdown(source) {
+  return source.split(/\n{2,}/).map((paragraph) => escape(paragraph.trim()).replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>").replace(/\b_(.+?)_\b/g, "<em>$1</em>").replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (match, label, href) => safeHref(href.replace(/&amp;/g, "&")) ? `<a href="${href}" target="_blank" rel="noopener" class="underline">${label}</a>` : match).replace(/\n/g, "<br>")).filter(Boolean).map((paragraph) => `<p>${paragraph}</p>`).join("");
+}

package/dist/runtime/utils/schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { FormDefinition, FormField } from '../../types.js';
+import type { Answers } from './conditions.js';
+import type { MessageTranslator } from './text.js';
+export type SchemaOptions = {
+    /** Translates the messages of rules the compiler adds itself. Defaults to English. */
+    t?: MessageTranslator;
+    /** Locale used for `validation.message` overrides from the definition. */
+    locale?: string;
+};
+/** Applied when a file field sets no `maxSize` / `maxFiles`, so uploads are always bounded. */
+export declare const DEFAULT_MAX_FILE_SIZE = 10000000;
+export declare const DEFAULT_MAX_FILES = 10;
+/** Builds the zod schema of a single field. */
+export declare function buildFieldSchema(field: FormField, options?: SchemaOptions): z.ZodType;
+/** Fields (with their step index) that take part in validation for these answers. */
+export declare function validatedFields(definition: FormDefinition, answers: Answers, stepIndex?: number): FormField[];
+/**
+ * Compiles the definition into a zod object for the answers given. Only visible fields are part
+ * of the schema, so hidden fields are never required and their answers are stripped.
+ * Pass `stepIndex` to validate one step (stepped client), omit it for the whole form (server).
+ */
+export declare function buildFormSchema(definition: FormDefinition, answers: Answers, options?: SchemaOptions & {
+    stepIndex?: number;
+}): z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strip>;

package/dist/runtime/utils/schema.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { isInputField, resolveVisibility } from "./conditions.js";
+import { defaultMessages, translate } from "./text.js";
+const EMAIL = /^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/;
+const PHONE = /^[+()\d\s-]{5,}$/;
+const DATE = /^\d{4}-\d{2}-\d{2}/;
+export const DEFAULT_MAX_FILE_SIZE = 1e7;
+export const DEFAULT_MAX_FILES = 10;
+const fileSchema = z.object({ name: z.string(), size: z.number(), type: z.string() });
+const matchesAccept = (type, accept) => accept.some((rule) => rule.endsWith("/*") ? type.startsWith(rule.slice(0, -1)) : type === rule);
+export function buildFieldSchema(field, options = {}) {
+  const t = options.t ?? defaultMessages;
+  const rules = field.validation ?? {};
+  const required = Boolean(field.required);
+  const override = rules.message ? translate(rules.message, options.locale) : void 0;
+  const message = (key, fallback, params) => override ?? t(`validation.${key}`, fallback, params);
+  const requiredMessage = () => message("required", "This field is required.");
+  if (field.type === "checkbox") {
+    const boolean = z.boolean({ error: requiredMessage });
+    return required ? boolean.refine((value) => value === true, { error: requiredMessage }) : boolean.optional();
+  }
+  if (field.type === "file") {
+    const files = z.array(fileSchema, { error: requiredMessage }).superRefine((value, ctx) => {
+      if (required && value.length === 0) ctx.addIssue({ code: "custom", message: requiredMessage() });
+      const maxFiles = rules.maxFiles ?? (field.multiple ? DEFAULT_MAX_FILES : 1);
+      if (value.length > maxFiles) {
+        ctx.addIssue({ code: "custom", message: message("maxFiles", "Upload at most {max} file(s).", { max: maxFiles }) });
+      }
+      const maxSize = rules.maxSize ?? DEFAULT_MAX_FILE_SIZE;
+      for (const file of value) {
+        if (file.size > maxSize) {
+          ctx.addIssue({
+            code: "custom",
+            message: message("maxSize", "{name} is larger than {max} MB.", { name: file.name, max: Math.round(maxSize / 1e6 * 10) / 10 })
+          });
+        }
+        if (rules.accept?.length && !matchesAccept(file.type, rules.accept)) {
+          ctx.addIssue({ code: "custom", message: message("accept", "{name} is not an accepted file type.", { name: file.name }) });
+        }
+      }
+    });
+    return required ? files : files.optional();
+  }
+  if (field.type === "number") {
+    const number = z.number({ error: requiredMessage }).superRefine((value, ctx) => {
+      if (rules.min !== void 0 && value < rules.min) {
+        ctx.addIssue({ code: "custom", message: message("min", "Must be at least {min}.", { min: rules.min }) });
+      }
+      if (rules.max !== void 0 && value > rules.max) {
+        ctx.addIssue({ code: "custom", message: message("max", "Must be at most {max}.", { max: rules.max }) });
+      }
+    });
+    return required ? number : number.nullish();
+  }
+  const allowed = field.options?.map((option) => option.value);
+  const text = z.string({ error: requiredMessage }).superRefine((raw, ctx) => {
+    const value = raw.trim();
+    if (!value) {
+      if (required) ctx.addIssue({ code: "custom", message: requiredMessage() });
+      return;
+    }
+    if (field.type === "email" && !EMAIL.test(value)) {
+      ctx.addIssue({ code: "custom", message: message("email", "Enter a valid email address.") });
+    }
+    if (field.type === "tel" && !PHONE.test(value)) {
+      ctx.addIssue({ code: "custom", message: message("tel", "Enter a valid phone number.") });
+    }
+    if (field.type === "date" && !DATE.test(value)) {
+      ctx.addIssue({ code: "custom", message: message("date", "Enter a valid date.") });
+    }
+    if ((field.type === "select" || field.type === "radio") && allowed && !allowed.includes(value)) {
+      ctx.addIssue({ code: "custom", message: message("option", "Choose one of the available options.") });
+    }
+    if (rules.minLength !== void 0 && value.length < rules.minLength) {
+      ctx.addIssue({ code: "custom", message: message("minLength", "Enter at least {min} characters.", { min: rules.minLength }) });
+    }
+    if (rules.maxLength !== void 0 && value.length > rules.maxLength) {
+      ctx.addIssue({ code: "custom", message: message("maxLength", "Enter at most {max} characters.", { max: rules.maxLength }) });
+    }
+    if (rules.pattern && !new RegExp(rules.pattern).test(value)) {
+      ctx.addIssue({ code: "custom", message: message("pattern", "The value has an invalid format.") });
+    }
+  });
+  return required ? text : text.optional();
+}
+export function validatedFields(definition, answers, stepIndex) {
+  return resolveVisibility(definition, answers).filter((visible) => stepIndex === void 0 || visible.index === stepIndex).flatMap((visible) => visible.fields).filter(isInputField);
+}
+export function buildFormSchema(definition, answers, options = {}) {
+  const shape = {};
+  for (const field of validatedFields(definition, answers, options.stepIndex)) {
+    shape[field.key] = buildFieldSchema(field, options);
+  }
+  return z.object(shape);
+}

package/dist/runtime/utils/text.d.ts

@@ -0,0 +1,12 @@
+import type { Translated } from '../../types.js';
+/** Picks the text for a locale, falling back to `en`, then to the first available entry. */
+export declare function translate(value: Translated | null | undefined, locale?: string): string;
+export type TranslateParams = Record<string, string | number>;
+/** `(key, englishFallback, params) => text`, the shape of `useModuleT('forms')`. */
+export type MessageTranslator = (key: string, fallback: string, params?: TranslateParams) => string;
+/** Replaces `{name}` placeholders. */
+export declare function interpolate(text: string, params?: TranslateParams): string;
+/** English-only translator, used on the server and wherever no i18n is available. */
+export declare const defaultMessages: MessageTranslator;
+/** Random, prefixed id (`frm_...`), Web Crypto only so it works on Workers. */
+export declare function newId(prefix: string): string;

package/dist/runtime/utils/text.js

@@ -0,0 +1,12 @@
+export function translate(value, locale = "en") {
+  if (!value) return "";
+  if (typeof value === "string") return value;
+  return value[locale] ?? value.en ?? Object.values(value)[0] ?? "";
+}
+export function interpolate(text, params = {}) {
+  return Object.entries(params).reduce((result, [name, value]) => result.replaceAll(`{${name}}`, String(value)), text);
+}
+export const defaultMessages = (_key, fallback, params) => interpolate(fallback, params);
+export function newId(prefix) {
+  return `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
+}

package/dist/types.d.mts

@@ -0,0 +1,3 @@
+export { default } from './module.mjs'
+
+export { type AuthorizeContext, type Condition, type ConditionOp, type DeliveredContext, type DeliveryStatus, type FieldOption, type FieldType, type FieldValidation, type FileDescriptor, type FormAdminDto, type FormDefinition, type FormDelivery, type FormField, type FormMode, type FormStatus, type FormStep, type FormStorage, type FormSubmitSettings, type FormSummaryDto, type FormsRuntimeConfig, type ModuleOptions, type PublicFormDto, type PublicModuleOptions, type SeedForm, type SubmissionDto, type SubmissionFileDto, type SubmissionSummaryDto, type SubmitResponse, type SubmittedContext, type SubmittedFile, type Translated } from './module.mjs'

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@frigear-nu/forms",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "Dynamic, database-stored forms (single page or stepped) with submissions, file uploads and email delivery for the frigear ecosystem.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/frigear-nu/frigear-nu.git",
+    "directory": "packages/forms"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/module.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/types.d.mts",
+      "import": "./dist/module.mjs",
+      "default": "./dist/module.mjs"
+    },
+    "./utils": {
+      "types": "./dist/runtime/utils/index.d.ts",
+      "import": "./dist/runtime/utils/index.js",
+      "default": "./dist/runtime/utils/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "playground"
+  ],
+  "dependencies": {
+    "@frigear-nu/menu": "0.0.3",
+    "@frigear-nu/module-kit": "0.1.2",
+    "@frigear-nu/notify": "0.0.3",
+    "@frigear-nu/users": "1.0.3",
+    "@libsql/client": "^0.18.0",
+    "@nuxt/kit": "^4.6.0",
+    "drizzle-kit": "^0.31.11",
+    "drizzle-orm": "^0.45.3",
+    "h3": "^1.15.11",
+    "unstorage": "^1.17.5",
+    "zod": "^4.6.5"
+  },
+  "peerDependencies": {
+    "@nuxt/ui": "^4.10.0",
+    "@nuxthub/core": "^0.10.8"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/ui": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@nuxt/devtools": "^3.4.2",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/module-builder": "^1.0.3",
+    "@nuxt/schema": "^4.6.0",
+    "@nuxt/test-utils": "^4.3.2",
+    "@nuxt/ui": "^4.11.0",
+    "@nuxthub/core": "^0.10.8",
+    "@types/node": "latest",
+    "changelogen": "^0.6.2",
+    "eslint": "^10.10.0",
+    "nuxt": "^4.6.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.1",
+    "vue-tsc": "^3.3.11"
+  },
+  "scripts": {
+    "postinstall": "nuxt-module-build build --stub && nuxt prepare",
+    "build": "nuxt-module-build build",
+    "dev": "npm run dev:prepare && nuxt dev playground",
+    "dev:build": "nuxt build playground",
+    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxt prepare playground",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --release && npm publish && git push --follow-tags",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  }
 }