@frigear-nu/forms 0.0.6 → 0.0.8

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

@@ -1,5 +1,37 @@
 import { z } from 'zod';
-import type { FormDefinition } from '../../types.js';
+import type { FormAccess, FormDefinition } from '../../types.js';
+export declare const accessSchema: z.ZodObject<{
+    availability: z.ZodDefault<z.ZodEnum<{
+        web: "web";
+        api: "api";
+    }>>;
+    auth: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        user: "user";
+        token: "token";
+        password: "password";
+    }>>;
+    schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"always">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"range">;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"yearly">;
+        from: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        to: z.ZodObject<{
+            month: z.ZodNumber;
+            day: z.ZodNumber;
+            time: z.ZodString;
+        }, z.core.$strip>;
+        timezone: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
 export declare const formDefinitionSchema: z.ZodObject<{
     mode: z.ZodEnum<{
         single: "single";
@@ -16,9 +48,11 @@ export declare const formDefinitionSchema: z.ZodObject<{
         showIf: z.ZodOptional<z.ZodObject<{
             field: z.ZodString;
             op: z.ZodEnum<{
+                in: "in";
                 eq: "eq";
                 neq: "neq";
-                in: "in";
+                empty: "empty";
+                notEmpty: "notEmpty";
                 truthy: "truthy";
             }>;
             value: z.ZodOptional<z.ZodUnknown>;
@@ -27,16 +61,17 @@ export declare const formDefinitionSchema: z.ZodObject<{
             key: z.ZodString;
             type: z.ZodEnum<{
                 number: "number";
-                text: "text";
+                date: "date";
+                file: "file";
                 email: "email";
+                text: "text";
                 tel: "tel";
                 textarea: "textarea";
                 select: "select";
                 radio: "radio";
                 checkbox: "checkbox";
-                date: "date";
-                file: "file";
                 markdown: "markdown";
+                captcha: "captcha";
             }>;
             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>]>>;
@@ -60,12 +95,39 @@ export declare const formDefinitionSchema: z.ZodObject<{
                 accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 message: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
             }, z.core.$strip>>;
+            phone: z.ZodOptional<z.ZodObject<{
+                mode: z.ZodOptional<z.ZodEnum<{
+                    simple: "simple";
+                    country: "country";
+                }>>;
+                countries: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                defaultCountry: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            captcha: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodOptional<z.ZodEnum<{
+                    turnstile: "turnstile";
+                    recaptcha: "recaptcha";
+                    hcaptcha: "hcaptcha";
+                }>>;
+                siteKey: z.ZodOptional<z.ZodString>;
+                theme: z.ZodOptional<z.ZodEnum<{
+                    auto: "auto";
+                    light: "light";
+                    dark: "dark";
+                }>>;
+                size: z.ZodOptional<z.ZodEnum<{
+                    normal: "normal";
+                    compact: "compact";
+                }>>;
+            }, z.core.$strip>>;
             showIf: z.ZodOptional<z.ZodObject<{
                 field: z.ZodString;
                 op: z.ZodEnum<{
+                    in: "in";
                     eq: "eq";
                     neq: "neq";
-                    in: "in";
+                    empty: "empty";
+                    notEmpty: "notEmpty";
                     truthy: "truthy";
                 }>;
                 value: z.ZodOptional<z.ZodUnknown>;
@@ -80,12 +142,60 @@ export declare const formDefinitionSchema: z.ZodObject<{
             keep: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    access: z.ZodOptional<z.ZodObject<{
+        availability: z.ZodDefault<z.ZodEnum<{
+            web: "web";
+            api: "api";
+        }>>;
+        auth: z.ZodDefault<z.ZodEnum<{
+            none: "none";
+            user: "user";
+            token: "token";
+            password: "password";
+        }>>;
+        schedule: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"always">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"range">;
+            from: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"yearly">;
+            from: z.ZodObject<{
+                month: z.ZodNumber;
+                day: z.ZodNumber;
+                time: z.ZodString;
+            }, z.core.$strip>;
+            to: z.ZodObject<{
+                month: z.ZodNumber;
+                day: z.ZodNumber;
+                time: z.ZodString;
+            }, z.core.$strip>;
+            timezone: z.ZodString;
+        }, z.core.$strip>], "type">>;
+    }, 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>]>>;
+            body: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+            routes: z.ZodOptional<z.ZodObject<{
+                field: z.ZodString;
+                to: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            replyToField: z.ZodOptional<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;
+/** Recipients and reply-to of an email delivery for the given answers (a matching route wins over `to`). */
+export declare function resolveEmailDelivery(email: NonNullable<NonNullable<FormDefinition['delivery']>['email']>, answers: Record<string, unknown>): {
+    to: string[];
+    replyTo: string | undefined;
+};
+export declare const defaultAccess: FormAccess;
+/** The effective access of a definition (older definitions have none and stay open). */
+export declare function resolveAccess(definition: {
+    access?: Partial<FormAccess>;
+}): FormAccess;

package/dist/runtime/utils/definition.js

@@ -1,15 +1,22 @@
 import { z } from "zod";
+import { scheduleSchema } from "@frigear-nu/module-kit/schedule";
+import { isPhoneCountry } from "./phone.js";
 const translated = z.union([z.string(), z.record(z.string(), z.string())]);
+const MAX_BODY = 1e4;
+const bodyText = z.union([
+  z.string().max(MAX_BODY),
+  z.record(z.string(), z.string().max(MAX_BODY))
+]);
 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"]),
+  op: z.enum(["eq", "neq", "in", "empty", "notEmpty", "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"]),
+  type: z.enum(["text", "email", "tel", "number", "textarea", "select", "radio", "checkbox", "date", "file", "markdown", "captcha"]),
   content: translated.optional(),
   label: translated.optional(),
   description: translated.optional(),
@@ -29,6 +36,17 @@ const field = z.object({
     accept: z.array(z.string()).optional(),
     message: translated.optional()
   }).optional(),
+  phone: z.object({
+    mode: z.enum(["simple", "country"]).optional(),
+    countries: z.array(z.string().toUpperCase().refine(isPhoneCountry, "Unknown country code.")).max(300).optional(),
+    defaultCountry: z.string().toUpperCase().refine(isPhoneCountry, "Unknown country code.").optional()
+  }).optional(),
+  captcha: z.object({
+    provider: z.enum(["turnstile", "recaptcha", "hcaptcha"]).optional(),
+    siteKey: z.string().max(200).regex(/^[\w-]*$/, "Site keys contain only letters, digits, dashes and underscores.").optional(),
+    theme: z.enum(["auto", "light", "dark"]).optional(),
+    size: z.enum(["normal", "compact"]).optional()
+  }).optional(),
   showIf: condition.optional()
 });
 const step = z.object({
@@ -40,6 +58,11 @@ const step = z.object({
 });
 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 accessSchema = z.object({
+  availability: z.enum(["web", "api"]).default("web"),
+  auth: z.enum(["none", "user", "token", "password"]).default("none"),
+  schedule: scheduleSchema.optional()
+});
 export const formDefinitionSchema = z.object({
   mode: z.enum(["single", "stepped"]),
   storage: z.enum(["db", "none"]).default("db"),
@@ -50,14 +73,24 @@ export const formDefinitionSchema = z.object({
     redirect: z.string().refine(sameOriginPath, "Redirect must be a path on this site.").optional(),
     allowResubmit: z.object({ keep: z.array(z.string()) }).optional()
   }).optional(),
+  access: accessSchema.optional(),
   delivery: z.object({
-    email: z.object({ to: z.array(emailAddress).min(1), subject: translated.optional() }).optional()
+    email: z.object({
+      to: z.array(emailAddress).min(1),
+      subject: translated.optional(),
+      body: bodyText.optional(),
+      routes: z.object({ field: z.string(), to: z.record(z.string(), z.array(emailAddress).min(1)) }).optional(),
+      replyToField: z.string().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"]);
   }
+  if (definition.access?.auth === "token" && definition.access.availability !== "api") {
+    fail("Token access needs the form to be API only.", ["access", "availability"]);
+  }
   const stepIds = /* @__PURE__ */ new Set();
   const keys = /* @__PURE__ */ new Map();
   definition.steps.forEach((s, stepIndex) => {
@@ -91,9 +124,16 @@ export const formDefinitionSchema = z.object({
     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);
+      if (f.type !== "markdown" && f.type !== "captcha") seen.add(f.key);
     });
   });
+  const emailDelivery = definition.delivery?.email;
+  if (emailDelivery?.routes && !seen.has(emailDelivery.routes.field)) {
+    fail(`Unknown field "${emailDelivery.routes.field}".`, ["delivery", "email", "routes", "field"]);
+  }
+  if (emailDelivery?.replyToField && keys.get(emailDelivery.replyToField) !== "email") {
+    fail("Reply-to must be an email field.", ["delivery", "email", "replyToField"]);
+  }
   definition.submit?.allowResubmit?.keep.forEach((key, index) => {
     if (!keys.has(key)) fail(`Unknown field "${key}".`, ["submit", "allowResubmit", "keep", index]);
   });
@@ -101,3 +141,12 @@ export const formDefinitionSchema = z.object({
 export function parseFormDefinition(input) {
   return formDefinitionSchema.parse(input);
 }
+export function resolveEmailDelivery(email, answers) {
+  const routed = email.routes?.to[String(answers[email.routes.field] ?? "")];
+  const replyTo = email.replyToField ? String(answers[email.replyToField] ?? "").trim() : "";
+  return { to: routed?.length ? routed : email.to, replyTo: replyTo || void 0 };
+}
+export const defaultAccess = { availability: "web", auth: "none" };
+export function resolveAccess(definition) {
+  return { ...defaultAccess, ...definition.access };
+}

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

@@ -0,0 +1,8 @@
+import type { FormAccessInfoDto } from '../../types.js';
+/** What `<FormEmbed>` renders for a form. */
+export type EmbedMode = 'form' | 'password' | 'sign-in' | 'hidden' | 'not-found';
+/**
+ * Picks what an embedded form shows from its access info. API-only forms and token forms have no
+ * public UI (a bearer token cannot be typed into a page), so they render nothing; a missing form is `not-found`.
+ */
+export declare function embedMode(access: FormAccessInfoDto | null | undefined): EmbedMode;

package/dist/runtime/utils/embed.js

@@ -0,0 +1,7 @@
+export function embedMode(access) {
+  if (!access) return "not-found";
+  if (access.access.availability === "api" || access.access.auth === "token") return "hidden";
+  if (access.access.auth === "user" && !access.signedIn) return "sign-in";
+  if (access.access.auth === "password") return "password";
+  return "form";
+}

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

@@ -1,13 +1,26 @@
 import type { FormDefinition } from '../../types.js';
 export type * from '../../types';
-export { translate, interpolate, defaultMessages, newId } from './text.js';
+export { interpolate, defaultMessages, newId } from './text.js';
+export { translate, readTranslated, writeTranslated, expandTranslated, collapseTranslated } from '@frigear-nu/ui/translated';
 export type { MessageTranslator, TranslateParams } from './text.js';
-export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField } from './conditions.js';
+export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField, isAnswerField } 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 { fieldTypes, arrayMove, moveField, moveStep, dropIndex, insertField, insertStep, removeField, updateField, updateStep, duplicateField, createField, createStep, removeStep, changeMode, pruneReferences, renameFieldKey, allFieldKeys, uniqueFieldKey, uniqueStepId, setEmailRecipients, patchEmailDelivery, setRouteField, setRoute, setStorage, setAccess, storageWarnings, emailFieldKeys, routableFields, } from './builder.js';
+export type { FieldPosition } from './builder.js';
+export { formDefinitionSchema, accessSchema, defaultAccess, resolveAccess, parseFormDefinition, resolveEmailDelivery } 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';
+export { captchaProviders, normalizeCaptchaProvider, resolveCaptcha } from './captcha.js';
+export { previewPayload, previewScale, PREVIEW_WIDTHS } from './preview.js';
+export type { PreviewDevice } from './preview.js';
+export { renderAnswers, formatValue, escapeHtml, answersToText, answersToHtml, composeEmail, renderTemplateText, renderTemplateHtml, renderTemplateLine, templateVariables, availableVariables, unknownBodyVariables, sampleAnswers, staticVariables, } from './template.js';
+export type { RenderedAnswer, EmailContext } from './template.js';
+export { allPhoneCountries, phoneCountries, defaultPhoneCountry, countryName, composePhone, parsePhone, phoneIssue, isPhoneCountry, isCountryPhone, } from './phone.js';
+export type { PhoneCountry } from './phone.js';
+export { embedMode } from './embed.js';
+export type { EmbedMode } from './embed.js';
+export { isFormOpen, nextFormOpening } from './schedule.js';

package/dist/runtime/utils/index.js

@@ -1,8 +1,71 @@
-export { translate, interpolate, defaultMessages, newId } from "./text.js";
-export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField } from "./conditions.js";
+export { interpolate, defaultMessages, newId } from "./text.js";
+export { translate, readTranslated, writeTranslated, expandTranslated, collapseTranslated } from "@frigear-nu/ui/translated";
+export { evaluateCondition, resolveVisibility, isFieldVisible, isInputField, isAnswerField } from "./conditions.js";
 export { buildFormSchema, buildFieldSchema, validatedFields } from "./schema.js";
-export { formDefinitionSchema, parseFormDefinition } from "./definition.js";
+export {
+  fieldTypes,
+  arrayMove,
+  moveField,
+  moveStep,
+  dropIndex,
+  insertField,
+  insertStep,
+  removeField,
+  updateField,
+  updateStep,
+  duplicateField,
+  createField,
+  createStep,
+  removeStep,
+  changeMode,
+  pruneReferences,
+  renameFieldKey,
+  allFieldKeys,
+  uniqueFieldKey,
+  uniqueStepId,
+  setEmailRecipients,
+  patchEmailDelivery,
+  setRouteField,
+  setRoute,
+  setStorage,
+  setAccess,
+  storageWarnings,
+  emailFieldKeys,
+  routableFields
+} from "./builder.js";
+export { formDefinitionSchema, accessSchema, defaultAccess, resolveAccess, parseFormDefinition, resolveEmailDelivery } from "./definition.js";
 export function defineForm(definition) {
   return definition;
 }
 export { renderMarkdown } from "./markdown.js";
+export { captchaProviders, normalizeCaptchaProvider, resolveCaptcha } from "./captcha.js";
+export { previewPayload, previewScale, PREVIEW_WIDTHS } from "./preview.js";
+export {
+  renderAnswers,
+  formatValue,
+  escapeHtml,
+  answersToText,
+  answersToHtml,
+  composeEmail,
+  renderTemplateText,
+  renderTemplateHtml,
+  renderTemplateLine,
+  templateVariables,
+  availableVariables,
+  unknownBodyVariables,
+  sampleAnswers,
+  staticVariables
+} from "./template.js";
+export {
+  allPhoneCountries,
+  phoneCountries,
+  defaultPhoneCountry,
+  countryName,
+  composePhone,
+  parsePhone,
+  phoneIssue,
+  isPhoneCountry,
+  isCountryPhone
+} from "./phone.js";
+export { embedMode } from "./embed.js";
+export { isFormOpen, nextFormOpening } from "./schedule.js";

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

@@ -1,5 +1 @@
-/**
- * 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;
+export { renderMarkdown } from '@frigear-nu/ui/markdown';

package/dist/runtime/utils/markdown.js

@@ -1,5 +1 @@
-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("");
-}
+export { renderMarkdown } from "@frigear-nu/ui/markdown";

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

@@ -0,0 +1,29 @@
+import type { FormField, PhoneConfig } from '../../types.js';
+export declare const DEFAULT_PHONE_COUNTRY = "DK";
+export type PhoneCountry = {
+    code: string;
+    dial: string;
+    flag: string;
+};
+export declare const allPhoneCountries: PhoneCountry[];
+export declare const isPhoneCountry: (code: string) => boolean;
+/** Whether the field collects its phone number with a separate country selector. */
+export declare const isCountryPhone: (field: Pick<FormField, "type" | "phone">) => boolean;
+/** The countries a phone field offers, in the order of its `countries` allow-list (unknown codes dropped), or every country. */
+export declare function phoneCountries(config?: PhoneConfig): PhoneCountry[];
+/** The preselected country: `defaultCountry` when offered, else Denmark when offered, else the first one offered. */
+export declare function defaultPhoneCountry(config?: PhoneConfig): string;
+/** Localised country name, falling back to the ISO code. */
+export declare function countryName(code: string, locale: string): string;
+/** Merges a country and the national number into the single stored value, e.g. `+4512345678`. Empty without digits. */
+export declare function composePhone(country: string, national: string): string;
+/**
+ * Splits a stored value back into country and national digits. Among the offered countries the longest
+ * matching dialing code wins; `preferred` wins between countries sharing that code (`+1`, `+44`, ...).
+ */
+export declare function parsePhone(value: string, config?: PhoneConfig, preferred?: string): {
+    country: string;
+    national: string;
+};
+/** Why a value is not an acceptable phone number for the field, or `undefined` when it is. */
+export declare function phoneIssue(field: Pick<FormField, 'phone'>, value: string): 'format' | 'country' | undefined;