payload-dynamic-forms 0.0.0-stage → 0.1.0

package/dist/shared/rules.js

@@ -0,0 +1,324 @@
+/** Lower-case kebab-case: ` Project Type ` → `project-type`. */ export function normalizeKey(value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+/**
+ * Splits a rule key into the field key and an optional option attribute:
+ * `Need.fieldSet` → `{ key: 'need', attribute: 'fieldSet' }`. The attribute keeps its case.
+ */ export function splitRuleKey(value) {
+    if (typeof value !== 'string') {
+        return {
+            key: ''
+        };
+    }
+    const trimmed = value.trim();
+    const dot = trimmed.indexOf('.');
+    if (dot === -1) {
+        return {
+            key: normalizeKey(trimmed)
+        };
+    }
+    const attribute = trimmed.slice(dot + 1).trim();
+    return {
+        attribute: attribute || undefined,
+        key: normalizeKey(trimmed.slice(0, dot))
+    };
+}
+export const DISPLAY_BLOCK_TYPES = [
+    'heading',
+    'helpText'
+];
+export const CHOICE_BLOCK_TYPES = [
+    'select',
+    'radio',
+    'checkboxGroup'
+];
+export function isInputBlock(block) {
+    return Boolean(block?.blockType) && !DISPLAY_BLOCK_TYPES.includes(block.blockType);
+}
+export function isChoiceBlock(block) {
+    return Boolean(block?.blockType) && CHOICE_BLOCK_TYPES.includes(block.blockType);
+}
+export function getFieldKey(block) {
+    return isInputBlock(block) ? normalizeKey(block.fieldKey) : '';
+}
+export function getSectionKey(section) {
+    return normalizeKey(section?.key);
+}
+export function getSections(form) {
+    return (form.sections || []).filter(Boolean);
+}
+/** Every input of the form in order, with its normalised key. */ export function getInputFields(form) {
+    return getSections(form).flatMap((section)=>(section.fields || []).filter(isInputBlock).map((field)=>({
+                field,
+                key: getFieldKey(field),
+                section
+            })).filter((entry)=>entry.key));
+}
+export function getInputFieldMap(form) {
+    const map = new Map();
+    for (const entry of getInputFields(form)){
+        if (!map.has(entry.key)) {
+            map.set(entry.key, entry);
+        }
+    }
+    return map;
+}
+export function getFieldLabel(field, key = getFieldKey(field)) {
+    return field.words?.label?.trim() || key;
+}
+export function getRowLabel(field, key = getFieldKey(field)) {
+    return field.words?.rowLabel?.trim() || getFieldLabel(field, key);
+}
+function isBlank(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return value.trim().length === 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object') {
+        const v = value;
+        if (Array.isArray(v.filenames)) {
+            return v.filenames.length === 0;
+        }
+        return Object.keys(v).length === 0;
+    }
+    return false;
+}
+/** True when an answer counts as given: `false` and empty strings, lists and objects don't. */ export function hasAnswer(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return !isBlank(value);
+}
+export function toStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry)=>String(entry ?? '').trim()).filter(Boolean);
+    }
+    if (typeof value === 'string') {
+        return value.split(',').map((entry)=>entry.trim()).filter(Boolean);
+    }
+    if (value === null || value === undefined || value === false) {
+        return [];
+    }
+    return [
+        String(value).trim()
+    ].filter(Boolean);
+}
+function asText(value) {
+    if (Array.isArray(value)) {
+        return value.map((v)=>String(v ?? '')).join(', ');
+    }
+    if (value === null || value === undefined) {
+        return '';
+    }
+    return String(value);
+}
+function compareNumberOrDate(left, right) {
+    const l = typeof left === 'number' ? left : Number(String(left ?? '').trim());
+    const r = typeof right === 'number' ? right : Number(String(right ?? '').trim());
+    const leftText = String(left ?? '').trim();
+    const rightText = String(right ?? '').trim();
+    if (leftText && rightText && Number.isFinite(l) && Number.isFinite(r)) {
+        return l - r;
+    }
+    const ld = Date.parse(leftText);
+    const rd = Date.parse(rightText);
+    if (!Number.isNaN(ld) && !Number.isNaN(rd)) {
+        return ld - rd;
+    }
+    return null;
+}
+/** The options a choice field offers (typed, or resolved from a source by the server). */ export function getOptions(field) {
+    return (field?.options || []).filter((o)=>Boolean(o && o.value != null));
+}
+/**
+ * The value a rule row reads: the answer, or for `<key>.<attribute>` the attribute of the
+ * chosen option(s) of that field.
+ */ export function readRuleValue(ruleKey, answers, form) {
+    const { attribute, key } = splitRuleKey(ruleKey);
+    if (!key) {
+        return undefined;
+    }
+    const answer = answers[key];
+    if (!attribute) {
+        return answer;
+    }
+    if (!form) {
+        return undefined;
+    }
+    const entry = getInputFieldMap(form).get(key);
+    const options = getOptions(entry?.field);
+    const chosen = toStringList(answer);
+    const values = chosen.map((value)=>options.find((o)=>String(o.value) === value)?.attributes?.[attribute]).filter((v)=>v !== undefined && v !== null);
+    if (Array.isArray(answer)) {
+        return values.map((v)=>String(v));
+    }
+    return values[0];
+}
+export function evaluateRow(row, answers, form) {
+    const operator = row?.operator;
+    if (!row || !operator || !splitRuleKey(row.fieldKey).key) {
+        return true;
+    }
+    const answer = readRuleValue(row.fieldKey, answers, form);
+    const expected = String(row.value ?? '').trim();
+    switch(operator){
+        case 'contains':
+            return asText(answer).toLowerCase().includes(expected.toLowerCase());
+        case 'equals':
+            return asText(answer).trim() === expected;
+        case 'greaterThan':
+            {
+                const c = compareNumberOrDate(answer, expected);
+                return c !== null && c > 0;
+            }
+        case 'hasValue':
+            return hasAnswer(answer);
+        case 'includesOption':
+            {
+                const haystack = toStringList(answer);
+                return toStringList(expected).some((needle)=>haystack.includes(needle));
+            }
+        case 'lessThan':
+            {
+                const c = compareNumberOrDate(answer, expected);
+                return c !== null && c < 0;
+            }
+        case 'notContains':
+            return !asText(answer).toLowerCase().includes(expected.toLowerCase());
+        case 'notEquals':
+            return asText(answer).trim() !== expected;
+        case 'notHasValue':
+            return !hasAnswer(answer);
+        default:
+            return true;
+    }
+}
+/** A group matches when all rows match (`all`, default) or any row does (`any`); empty matches. */ export function evaluateRules(group, answers, form) {
+    const rows = (group?.rows || []).filter(Boolean);
+    if (!rows.length) {
+        return true;
+    }
+    if (group?.match === 'any') {
+        return rows.some((row)=>evaluateRow(row, answers, form));
+    }
+    return rows.every((row)=>evaluateRow(row, answers, form));
+}
+export function isSectionVisible(section, answers, form) {
+    return evaluateRules(section.visibilityRules, answers, form);
+}
+/** A field is shown when its section is shown and its own rules match. */ export function isFieldVisible(section, field, answers, form) {
+    if (!isSectionVisible(section, answers, form)) {
+        return false;
+    }
+    if (!isInputBlock(field)) {
+        return true;
+    }
+    return evaluateRules(field.visibilityRules, answers, form);
+}
+export function getVisibleSections(form, answers) {
+    return getSections(form).filter((section)=>isSectionVisible(section, answers, form));
+}
+function readParam(params, name) {
+    if (!params || !name) {
+        return [];
+    }
+    if (typeof params === 'string') {
+        return new URLSearchParams(params).getAll(name);
+    }
+    if (typeof params.get === 'function') {
+        const p = params;
+        if (typeof p.getAll === 'function') {
+            return p.getAll(name);
+        }
+        const v = p.get(name);
+        return v === null ? [] : [
+            v
+        ];
+    }
+    const v = params[name];
+    if (v === undefined) {
+        return [];
+    }
+    return Array.isArray(v) ? v : [
+        v
+    ];
+}
+/** The starting answer of a field from its default value. */ export function defaultAnswer(field) {
+    const d = field.defaultValue;
+    if (field.blockType === 'checkbox') {
+        return d === true || [
+            '1',
+            'on',
+            'true',
+            'yes'
+        ].includes(String(d ?? '').toLowerCase());
+    }
+    if (field.blockType === 'checkboxGroup') {
+        return toStringList(d);
+    }
+    if (field.blockType === 'fileUpload') {
+        return '';
+    }
+    if (d === null || d === undefined) {
+        return '';
+    }
+    if (typeof d === 'number' || typeof d === 'boolean') {
+        return d;
+    }
+    return String(d);
+}
+/**
+ * Starting answers for a renderer: each input's default, or the value of its link parameter
+ * when the app passes the page's search parameters. Choice fields take the parameter only when
+ * it is one of their options.
+ */ export function initialAnswers(form, searchParams) {
+    const answers = {};
+    for (const { field, key } of getInputFields(form)){
+        answers[key] = defaultAnswer(field);
+        const param = field.prefillParam?.trim();
+        if (!param || field.blockType === 'fileUpload') {
+            continue;
+        }
+        const raw = readParam(searchParams, param).flatMap((v)=>field.blockType === 'checkboxGroup' ? toStringList(v) : [
+                v.trim()
+            ]).filter(Boolean);
+        if (!raw.length) {
+            continue;
+        }
+        if (isChoiceBlock(field)) {
+            const listed = new Set(getOptions(field).map((o)=>String(o.value)));
+            const ok = raw.filter((v)=>listed.has(v));
+            if (!ok.length) {
+                continue;
+            }
+            answers[key] = field.blockType === 'checkboxGroup' ? ok : ok[0];
+            continue;
+        }
+        if (field.blockType === 'checkbox') {
+            answers[key] = [
+                '1',
+                'on',
+                'true',
+                'yes'
+            ].includes(raw[0].toLowerCase());
+            continue;
+        }
+        if (field.blockType === 'number') {
+            const n = Number(raw[0]);
+            answers[key] = Number.isFinite(n) ? n : raw[0];
+            continue;
+        }
+        answers[key] = raw[0];
+    }
+    return answers;
+}
+
+//# sourceMappingURL=rules.js.map

package/dist/shared/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/shared/rules.ts"],"sourcesContent":["import type {\n  Answers,\n  AnswerValue,\n  ChoiceOption,\n  FieldBlock,\n  FormLike,\n  FormSection,\n  InputBlock,\n  RuleGroup,\n  RuleRow,\n} from './types.js'\n\n/** Lower-case kebab-case: ` Project Type ` → `project-type`. */\nexport function normalizeKey(value: unknown): string {\n  if (typeof value !== 'string') {\n    return ''\n  }\n  return value\n    .trim()\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, '-')\n    .replace(/^-+|-+$/g, '')\n}\n\n/**\n * Splits a rule key into the field key and an optional option attribute:\n * `Need.fieldSet` → `{ key: 'need', attribute: 'fieldSet' }`. The attribute keeps its case.\n */\nexport function splitRuleKey(value: unknown): { attribute?: string; key: string } {\n  if (typeof value !== 'string') {\n    return { key: '' }\n  }\n  const trimmed = value.trim()\n  const dot = trimmed.indexOf('.')\n  if (dot === -1) {\n    return { key: normalizeKey(trimmed) }\n  }\n  const attribute = trimmed.slice(dot + 1).trim()\n  return { attribute: attribute || undefined, key: normalizeKey(trimmed.slice(0, dot)) }\n}\n\nexport const DISPLAY_BLOCK_TYPES: readonly string[] = ['heading', 'helpText']\nexport const CHOICE_BLOCK_TYPES: readonly string[] = ['select', 'radio', 'checkboxGroup']\n\nexport function isInputBlock(block: FieldBlock | null | undefined): block is InputBlock {\n  return Boolean(block?.blockType) && !DISPLAY_BLOCK_TYPES.includes(block!.blockType)\n}\n\nexport function isChoiceBlock(block: FieldBlock | null | undefined): boolean {\n  return Boolean(block?.blockType) && CHOICE_BLOCK_TYPES.includes(block!.blockType)\n}\n\nexport function getFieldKey(block: FieldBlock | null | undefined): string {\n  return isInputBlock(block) ? normalizeKey(block.fieldKey) : ''\n}\n\nexport function getSectionKey(section: FormSection | null | undefined): string {\n  return normalizeKey(section?.key)\n}\n\nexport function getSections(form: FormLike): FormSection[] {\n  return (form.sections || []).filter(Boolean)\n}\n\nexport type InputEntry = { field: InputBlock; key: string; section: FormSection }\n\n/** Every input of the form in order, with its normalised key. */\nexport function getInputFields(form: FormLike): InputEntry[] {\n  return getSections(form).flatMap((section) =>\n    (section.fields || [])\n      .filter(isInputBlock)\n      .map((field) => ({ field, key: getFieldKey(field), section }))\n      .filter((entry) => entry.key),\n  )\n}\n\nexport function getInputFieldMap(form: FormLike): Map<string, InputEntry> {\n  const map = new Map<string, InputEntry>()\n  for (const entry of getInputFields(form)) {\n    if (!map.has(entry.key)) {\n      map.set(entry.key, entry)\n    }\n  }\n  return map\n}\n\nexport function getFieldLabel(field: InputBlock, key = getFieldKey(field)): string {\n  return field.words?.label?.trim() || key\n}\n\nexport function getRowLabel(field: InputBlock, key = getFieldKey(field)): string {\n  return field.words?.rowLabel?.trim() || getFieldLabel(field, key)\n}\n\nfunction isBlank(value: unknown): boolean {\n  if (value === null || value === undefined) {\n    return true\n  }\n  if (typeof value === 'string') {\n    return value.trim().length === 0\n  }\n  if (Array.isArray(value)) {\n    return value.length === 0\n  }\n  if (typeof value === 'object') {\n    const v = value as Record<string, unknown>\n    if (Array.isArray(v.filenames)) {\n      return v.filenames.length === 0\n    }\n    return Object.keys(v).length === 0\n  }\n  return false\n}\n\n/** True when an answer counts as given: `false` and empty strings, lists and objects don't. */\nexport function hasAnswer(value: unknown): boolean {\n  if (typeof value === 'boolean') {\n    return value\n  }\n  return !isBlank(value)\n}\n\nexport function toStringList(value: unknown): string[] {\n  if (Array.isArray(value)) {\n    return value.map((entry) => String(entry ?? '').trim()).filter(Boolean)\n  }\n  if (typeof value === 'string') {\n    return value\n      .split(',')\n      .map((entry) => entry.trim())\n      .filter(Boolean)\n  }\n  if (value === null || value === undefined || value === false) {\n    return []\n  }\n  return [String(value).trim()].filter(Boolean)\n}\n\nfunction asText(value: unknown): string {\n  if (Array.isArray(value)) {\n    return value.map((v) => String(v ?? '')).join(', ')\n  }\n  if (value === null || value === undefined) {\n    return ''\n  }\n  return String(value)\n}\n\nfunction compareNumberOrDate(left: unknown, right: unknown): null | number {\n  const l = typeof left === 'number' ? left : Number(String(left ?? '').trim())\n  const r = typeof right === 'number' ? right : Number(String(right ?? '').trim())\n  const leftText = String(left ?? '').trim()\n  const rightText = String(right ?? '').trim()\n  if (leftText && rightText && Number.isFinite(l) && Number.isFinite(r)) {\n    return l - r\n  }\n  const ld = Date.parse(leftText)\n  const rd = Date.parse(rightText)\n  if (!Number.isNaN(ld) && !Number.isNaN(rd)) {\n    return ld - rd\n  }\n  return null\n}\n\n/** The options a choice field offers (typed, or resolved from a source by the server). */\nexport function getOptions(field: InputBlock | undefined): ChoiceOption[] {\n  return (field?.options || []).filter((o): o is ChoiceOption => Boolean(o && o.value != null))\n}\n\n/**\n * The value a rule row reads: the answer, or for `<key>.<attribute>` the attribute of the\n * chosen option(s) of that field.\n */\nexport function readRuleValue(ruleKey: unknown, answers: Answers, form?: FormLike): unknown {\n  const { attribute, key } = splitRuleKey(ruleKey)\n  if (!key) {\n    return undefined\n  }\n  const answer = answers[key]\n  if (!attribute) {\n    return answer\n  }\n  if (!form) {\n    return undefined\n  }\n  const entry = getInputFieldMap(form).get(key)\n  const options = getOptions(entry?.field)\n  const chosen = toStringList(answer)\n  const values = chosen\n    .map((value) => options.find((o) => String(o.value) === value)?.attributes?.[attribute])\n    .filter((v) => v !== undefined && v !== null)\n  if (Array.isArray(answer)) {\n    return values.map((v) => String(v))\n  }\n  return values[0]\n}\n\nexport function evaluateRow(row: null | RuleRow | undefined, answers: Answers, form?: FormLike): boolean {\n  const operator = row?.operator\n  if (!row || !operator || !splitRuleKey(row.fieldKey).key) {\n    return true\n  }\n  const answer = readRuleValue(row.fieldKey, answers, form)\n  const expected = String(row.value ?? '').trim()\n\n  switch (operator) {\n    case 'contains':\n      return asText(answer).toLowerCase().includes(expected.toLowerCase())\n    case 'equals':\n      return asText(answer).trim() === expected\n    case 'greaterThan': {\n      const c = compareNumberOrDate(answer, expected)\n      return c !== null && c > 0\n    }\n    case 'hasValue':\n      return hasAnswer(answer)\n    case 'includesOption': {\n      const haystack = toStringList(answer)\n      return toStringList(expected).some((needle) => haystack.includes(needle))\n    }\n    case 'lessThan': {\n      const c = compareNumberOrDate(answer, expected)\n      return c !== null && c < 0\n    }\n    case 'notContains':\n      return !asText(answer).toLowerCase().includes(expected.toLowerCase())\n    case 'notEquals':\n      return asText(answer).trim() !== expected\n    case 'notHasValue':\n      return !hasAnswer(answer)\n    default:\n      return true\n  }\n}\n\n/** A group matches when all rows match (`all`, default) or any row does (`any`); empty matches. */\nexport function evaluateRules(\n  group: null | RuleGroup | undefined,\n  answers: Answers,\n  form?: FormLike,\n): boolean {\n  const rows = (group?.rows || []).filter(Boolean)\n  if (!rows.length) {\n    return true\n  }\n  if (group?.match === 'any') {\n    return rows.some((row) => evaluateRow(row, answers, form))\n  }\n  return rows.every((row) => evaluateRow(row, answers, form))\n}\n\nexport function isSectionVisible(section: FormSection, answers: Answers, form?: FormLike): boolean {\n  return evaluateRules(section.visibilityRules, answers, form)\n}\n\n/** A field is shown when its section is shown and its own rules match. */\nexport function isFieldVisible(\n  section: FormSection,\n  field: FieldBlock,\n  answers: Answers,\n  form?: FormLike,\n): boolean {\n  if (!isSectionVisible(section, answers, form)) {\n    return false\n  }\n  if (!isInputBlock(field)) {\n    return true\n  }\n  return evaluateRules(field.visibilityRules, answers, form)\n}\n\nexport function getVisibleSections(form: FormLike, answers: Answers): FormSection[] {\n  return getSections(form).filter((section) => isSectionVisible(section, answers, form))\n}\n\ntype SearchParamsLike =\n  | { get(name: string): null | string; getAll?(name: string): string[] }\n  | Record<string, string | string[] | undefined>\n  | string\n  | URLSearchParams\n\nfunction readParam(params: SearchParamsLike | undefined, name: string): string[] {\n  if (!params || !name) {\n    return []\n  }\n  if (typeof params === 'string') {\n    return new URLSearchParams(params).getAll(name)\n  }\n  if (typeof (params as URLSearchParams).get === 'function') {\n    const p = params as URLSearchParams\n    if (typeof p.getAll === 'function') {\n      return p.getAll(name)\n    }\n    const v = p.get(name)\n    return v === null ? [] : [v]\n  }\n  const v = (params as Record<string, string | string[] | undefined>)[name]\n  if (v === undefined) {\n    return []\n  }\n  return Array.isArray(v) ? v : [v]\n}\n\n/** The starting answer of a field from its default value. */\nexport function defaultAnswer(field: InputBlock): AnswerValue {\n  const d = field.defaultValue\n  if (field.blockType === 'checkbox') {\n    return d === true || ['1', 'on', 'true', 'yes'].includes(String(d ?? '').toLowerCase())\n  }\n  if (field.blockType === 'checkboxGroup') {\n    return toStringList(d)\n  }\n  if (field.blockType === 'fileUpload') {\n    return ''\n  }\n  if (d === null || d === undefined) {\n    return ''\n  }\n  if (typeof d === 'number' || typeof d === 'boolean') {\n    return d\n  }\n  return String(d)\n}\n\n/**\n * Starting answers for a renderer: each input's default, or the value of its link parameter\n * when the app passes the page's search parameters. Choice fields take the parameter only when\n * it is one of their options.\n */\nexport function initialAnswers(form: FormLike, searchParams?: SearchParamsLike): Answers {\n  const answers: Answers = {}\n  for (const { field, key } of getInputFields(form)) {\n    answers[key] = defaultAnswer(field)\n    const param = field.prefillParam?.trim()\n    if (!param || field.blockType === 'fileUpload') {\n      continue\n    }\n    const raw = readParam(searchParams, param)\n      .flatMap((v) => (field.blockType === 'checkboxGroup' ? toStringList(v) : [v.trim()]))\n      .filter(Boolean)\n    if (!raw.length) {\n      continue\n    }\n    if (isChoiceBlock(field)) {\n      const listed = new Set(getOptions(field).map((o) => String(o.value)))\n      const ok = raw.filter((v) => listed.has(v))\n      if (!ok.length) {\n        continue\n      }\n      answers[key] = field.blockType === 'checkboxGroup' ? ok : ok[0]\n      continue\n    }\n    if (field.blockType === 'checkbox') {\n      answers[key] = ['1', 'on', 'true', 'yes'].includes(raw[0].toLowerCase())\n      continue\n    }\n    if (field.blockType === 'number') {\n      const n = Number(raw[0])\n      answers[key] = Number.isFinite(n) ? n : raw[0]\n      continue\n    }\n    answers[key] = raw[0]!\n  }\n  return answers\n}\n"],"names":["normalizeKey","value","trim","toLowerCase","replace","splitRuleKey","key","trimmed","dot","indexOf","attribute","slice","undefined","DISPLAY_BLOCK_TYPES","CHOICE_BLOCK_TYPES","isInputBlock","block","Boolean","blockType","includes","isChoiceBlock","getFieldKey","fieldKey","getSectionKey","section","getSections","form","sections","filter","getInputFields","flatMap","fields","map","field","entry","getInputFieldMap","Map","has","set","getFieldLabel","words","label","getRowLabel","rowLabel","isBlank","length","Array","isArray","v","filenames","Object","keys","hasAnswer","toStringList","String","split","asText","join","compareNumberOrDate","left","right","l","Number","r","leftText","rightText","isFinite","ld","Date","parse","rd","isNaN","getOptions","options","o","readRuleValue","ruleKey","answers","answer","get","chosen","values","find","attributes","evaluateRow","row","operator","expected","c","haystack","some","needle","evaluateRules","group","rows","match","every","isSectionVisible","visibilityRules","isFieldVisible","getVisibleSections","readParam","params","name","URLSearchParams","getAll","p","defaultAnswer","d","defaultValue","initialAnswers","searchParams","param","prefillParam","raw","listed","Set","ok","n"],"mappings":"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"}

package/dist/shared/steps.d.ts

@@ -0,0 +1,28 @@
+import type { Answers, FormLike, FormWords } from './types.js';
+/**
+ * The sections a visitor goes through. Step-by-step forms start at the first visible section;
+ * from each section the first matching next-step rule that targets a visible section wins, else
+ * the next visible section. Single-page forms: every visible section.
+ */
+export declare function getStepPath(form: FormLike, answers: Answers): string[];
+/** The section after `currentKey` on the path, or null at the end. */
+export declare function getNextSectionKey(form: FormLike, currentKey: string, answers: Answers): null | string;
+/** Where a visitor is on the path: `current` of `total`, and the form's step progress words. */
+export declare function getStepProgress(form: FormLike, answers: Answers, currentKey: string, words?: Partial<FormWords>): {
+    current: number;
+    text: string;
+    total: number;
+};
+export type Visibility = {
+    /** Answers of the shown fields only. */
+    answers: Answers;
+    /** Keys of the inputs that are shown (and, in steps, on the path). */
+    fieldKeys: Set<string>;
+    /** Keys of the sections that count: visible ones, or in steps the ones on the path. */
+    sectionKeys: string[];
+};
+/**
+ * What is shown for these answers. Hidden answers are dropped and the rules are read again until
+ * nothing changes, so an answer left in a hidden field never decides what else is shown.
+ */
+export declare function getVisibility(form: FormLike, answers: Answers): Visibility;

package/dist/shared/steps.js

@@ -0,0 +1,109 @@
+import { evaluateRules, getInputFields, getSectionKey, getVisibleSections, isSectionVisible, normalizeKey } from './rules.js';
+import { interpolate } from './tokens.js';
+import { DEFAULT_WORDS } from './words.js';
+function nextFrom(form, visible, index, answers) {
+    const section = visible[index];
+    for (const rule of (section.nextStepRules || []).filter(Boolean)){
+        if (!evaluateRules(rule, answers, form)) {
+            continue;
+        }
+        const target = normalizeKey(rule.targetSectionKey);
+        const targetIndex = visible.findIndex((s)=>getSectionKey(s) === target);
+        if (target && targetIndex !== -1) {
+            return targetIndex;
+        }
+    }
+    return index + 1;
+}
+/**
+ * The sections a visitor goes through. Step-by-step forms start at the first visible section;
+ * from each section the first matching next-step rule that targets a visible section wins, else
+ * the next visible section. Single-page forms: every visible section.
+ */ export function getStepPath(form, answers) {
+    const visible = getVisibleSections(form, answers);
+    if (form.presentationMode !== 'steps') {
+        return visible.map(getSectionKey);
+    }
+    const path = [];
+    const seen = new Set();
+    let index = 0;
+    while(index < visible.length && !seen.has(index)){
+        seen.add(index);
+        path.push(getSectionKey(visible[index]));
+        index = nextFrom(form, visible, index, answers);
+    }
+    return path;
+}
+/** The section after `currentKey` on the path, or null at the end. */ export function getNextSectionKey(form, currentKey, answers) {
+    const visible = getVisibleSections(form, answers);
+    const index = visible.findIndex((s)=>getSectionKey(s) === normalizeKey(currentKey));
+    if (index === -1) {
+        return visible[0] ? getSectionKey(visible[0]) : null;
+    }
+    const next = nextFrom(form, visible, index, answers);
+    return visible[next] ? getSectionKey(visible[next]) : null;
+}
+/** Where a visitor is on the path: `current` of `total`, and the form's step progress words. */ export function getStepProgress(form, answers, currentKey, words) {
+    const path = getStepPath(form, answers);
+    const current = path.indexOf(normalizeKey(currentKey)) + 1;
+    const total = path.length;
+    const template = words?.stepProgress || form.wording?.stepProgress || DEFAULT_WORDS.stepProgress;
+    return {
+        current,
+        text: interpolate(template, {
+            current,
+            total
+        }),
+        total
+    };
+}
+/**
+ * What is shown for these answers. Hidden answers are dropped and the rules are read again until
+ * nothing changes, so an answer left in a hidden field never decides what else is shown.
+ */ export function getVisibility(form, answers) {
+    const inputs = getInputFields(form);
+    let current = answers;
+    let result = {
+        answers: {},
+        fieldKeys: new Set(),
+        sectionKeys: []
+    };
+    for(let round = 0; round < 10; round += 1){
+        const sectionKeys = getStepPath(form, current);
+        const active = new Set(sectionKeys);
+        const fieldKeys = new Set();
+        for (const { field, key, section } of inputs){
+            if (!active.has(getSectionKey(section))) {
+                continue;
+            }
+            if (!isSectionVisible(section, current, form)) {
+                continue;
+            }
+            if (!evaluateRules(field.visibilityRules, current, form)) {
+                continue;
+            }
+            fieldKeys.add(key);
+        }
+        const next = {};
+        for (const key of fieldKeys){
+            if (key in answers) {
+                next[key] = answers[key];
+            }
+        }
+        const same = result.fieldKeys.size === fieldKeys.size && [
+            ...fieldKeys
+        ].every((k)=>result.fieldKeys.has(k));
+        result = {
+            answers: next,
+            fieldKeys,
+            sectionKeys
+        };
+        if (same && round > 0) {
+            break;
+        }
+        current = next;
+    }
+    return result;
+}
+
+//# sourceMappingURL=steps.js.map

package/dist/shared/steps.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/shared/steps.ts"],"sourcesContent":["import type { Answers, FormLike, FormSection, FormWords } from './types.js'\n\nimport {\n  evaluateRules,\n  getInputFields,\n  getSectionKey,\n  getVisibleSections,\n  isSectionVisible,\n  normalizeKey,\n} from './rules.js'\nimport { interpolate } from './tokens.js'\nimport { DEFAULT_WORDS } from './words.js'\n\nfunction nextFrom(\n  form: FormLike,\n  visible: FormSection[],\n  index: number,\n  answers: Answers,\n): number {\n  const section = visible[index]\n  for (const rule of (section.nextStepRules || []).filter(Boolean)) {\n    if (!evaluateRules(rule, answers, form)) {\n      continue\n    }\n    const target = normalizeKey(rule.targetSectionKey)\n    const targetIndex = visible.findIndex((s) => getSectionKey(s) === target)\n    if (target && targetIndex !== -1) {\n      return targetIndex\n    }\n  }\n  return index + 1\n}\n\n/**\n * The sections a visitor goes through. Step-by-step forms start at the first visible section;\n * from each section the first matching next-step rule that targets a visible section wins, else\n * the next visible section. Single-page forms: every visible section.\n */\nexport function getStepPath(form: FormLike, answers: Answers): string[] {\n  const visible = getVisibleSections(form, answers)\n  if (form.presentationMode !== 'steps') {\n    return visible.map(getSectionKey)\n  }\n  const path: string[] = []\n  const seen = new Set<number>()\n  let index = 0\n  while (index < visible.length && !seen.has(index)) {\n    seen.add(index)\n    path.push(getSectionKey(visible[index]))\n    index = nextFrom(form, visible, index, answers)\n  }\n  return path\n}\n\n/** The section after `currentKey` on the path, or null at the end. */\nexport function getNextSectionKey(form: FormLike, currentKey: string, answers: Answers): null | string {\n  const visible = getVisibleSections(form, answers)\n  const index = visible.findIndex((s) => getSectionKey(s) === normalizeKey(currentKey))\n  if (index === -1) {\n    return visible[0] ? getSectionKey(visible[0]) : null\n  }\n  const next = nextFrom(form, visible, index, answers)\n  return visible[next] ? getSectionKey(visible[next]) : null\n}\n\n/** Where a visitor is on the path: `current` of `total`, and the form's step progress words. */\nexport function getStepProgress(\n  form: FormLike,\n  answers: Answers,\n  currentKey: string,\n  words?: Partial<FormWords>,\n): { current: number; text: string; total: number } {\n  const path = getStepPath(form, answers)\n  const current = path.indexOf(normalizeKey(currentKey)) + 1\n  const total = path.length\n  const template = words?.stepProgress || form.wording?.stepProgress || DEFAULT_WORDS.stepProgress\n  return { current, text: interpolate(template, { current, total }), total }\n}\n\nexport type Visibility = {\n  /** Answers of the shown fields only. */\n  answers: Answers\n  /** Keys of the inputs that are shown (and, in steps, on the path). */\n  fieldKeys: Set<string>\n  /** Keys of the sections that count: visible ones, or in steps the ones on the path. */\n  sectionKeys: string[]\n}\n\n/**\n * What is shown for these answers. Hidden answers are dropped and the rules are read again until\n * nothing changes, so an answer left in a hidden field never decides what else is shown.\n */\nexport function getVisibility(form: FormLike, answers: Answers): Visibility {\n  const inputs = getInputFields(form)\n  let current: Answers = answers\n  let result: Visibility = { answers: {}, fieldKeys: new Set(), sectionKeys: [] }\n  for (let round = 0; round < 10; round += 1) {\n    const sectionKeys = getStepPath(form, current)\n    const active = new Set(sectionKeys)\n    const fieldKeys = new Set<string>()\n    for (const { field, key, section } of inputs) {\n      if (!active.has(getSectionKey(section))) {\n        continue\n      }\n      if (!isSectionVisible(section, current, form)) {\n        continue\n      }\n      if (!evaluateRules(field.visibilityRules, current, form)) {\n        continue\n      }\n      fieldKeys.add(key)\n    }\n    const next: Answers = {}\n    for (const key of fieldKeys) {\n      if (key in answers) {\n        next[key] = answers[key]!\n      }\n    }\n    const same =\n      result.fieldKeys.size === fieldKeys.size && [...fieldKeys].every((k) => result.fieldKeys.has(k))\n    result = { answers: next, fieldKeys, sectionKeys }\n    if (same && round > 0) {\n      break\n    }\n    current = next\n  }\n  return result\n}\n"],"names":["evaluateRules","getInputFields","getSectionKey","getVisibleSections","isSectionVisible","normalizeKey","interpolate","DEFAULT_WORDS","nextFrom","form","visible","index","answers","section","rule","nextStepRules","filter","Boolean","target","targetSectionKey","targetIndex","findIndex","s","getStepPath","presentationMode","map","path","seen","Set","length","has","add","push","getNextSectionKey","currentKey","next","getStepProgress","words","current","indexOf","total","template","stepProgress","wording","text","getVisibility","inputs","result","fieldKeys","sectionKeys","round","active","field","key","visibilityRules","same","size","every","k"],"mappings":"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"}

package/dist/shared/tokens.d.ts

@@ -0,0 +1,25 @@
+import type { Answers, FieldTypeChecks, FormLike } from './types.js';
+export type TokenValue = boolean | null | number | string | undefined;
+export type MessageRow = {
+    key: string;
+    label: string;
+    value: string;
+};
+export type InterpolateOptions = {
+    /** Escape values for HTML and turn `{{*}}` lines into `<br>`. */
+    html?: boolean;
+    /** Rows for `{{*}}` and `{{*:table}}`. */
+    rows?: MessageRow[];
+    /** Remove line breaks (for subjects and headers). */
+    singleLine?: boolean;
+};
+export declare function escapeHtml(value: string): string;
+/**
+ * Fills `{{key}}` (dashes and underscores allowed), `{{key.attribute}}`, `{{*}}` and
+ * `{{*:table}}`. Unknown tokens become empty.
+ */
+export declare function interpolate(template: null | string | undefined, values: Record<string, TokenValue>, options?: InterpolateOptions): string;
+/** One row per answered, shown field, in form order, using each field's row label. */
+export declare function buildMessageRows(form: FormLike, answers: Answers, fieldTypes?: Record<string, FieldTypeChecks>): MessageRow[];
+/** Token values for a form's shown answers: `{{key}}`, `{{key.attribute}}` plus `extra`. */
+export declare function buildTemplateValues(form: FormLike, answers: Answers, extra?: Record<string, TokenValue>, fieldTypes?: Record<string, FieldTypeChecks>): Record<string, TokenValue>;

package/dist/shared/tokens.js

@@ -0,0 +1,96 @@
+import { answerToText } from './answers.js';
+import { getInputFields, getOptions, getRowLabel, hasAnswer, isChoiceBlock, toStringList } from './rules.js';
+import { getVisibility } from './steps.js';
+import { fillWords } from './words.js';
+const TOKEN = /\{\{\s*(\*(?::table)?|\w[\w-]*(?:\.[\w-]+)?)\s*\}\}/g;
+export function escapeHtml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+function rowsAsLines(rows, html) {
+    const lines = rows.map((row)=>`${row.label}: ${row.value}`);
+    return html ? lines.map(escapeHtml).join('<br>\n') : lines.join('\n');
+}
+function rowsAsTable(rows, html) {
+    if (!html) {
+        return rowsAsLines(rows, false);
+    }
+    const body = rows.map((row)=>`<tr><th align="left">${escapeHtml(row.label)}</th><td>${escapeHtml(row.value)}</td></tr>`).join('');
+    return `<table><tbody>${body}</tbody></table>`;
+}
+/**
+ * Fills `{{key}}` (dashes and underscores allowed), `{{key.attribute}}`, `{{*}}` and
+ * `{{*:table}}`. Unknown tokens become empty.
+ */ export function interpolate(template, values, options = {}) {
+    if (!template) {
+        return '';
+    }
+    const html = Boolean(options.html);
+    const out = template.replace(TOKEN, (_match, name)=>{
+        if (name === '*') {
+            return rowsAsLines(options.rows || [], html);
+        }
+        if (name === '*:table') {
+            return rowsAsTable(options.rows || [], html);
+        }
+        const value = values[name];
+        const text = value === undefined || value === null ? '' : String(value);
+        return html ? escapeHtml(text) : text;
+    });
+    return options.singleLine ? out.replace(/[\r\n]+/g, ' ').trim() : out;
+}
+/** One row per answered, shown field, in form order, using each field's row label. */ export function buildMessageRows(form, answers, fieldTypes) {
+    const { answers: shown } = getVisibility(form, answers);
+    const words = fillWords(form.wording);
+    const rows = [];
+    for (const { field, key } of getInputFields(form)){
+        if (!(key in shown) || !hasAnswer(shown[key])) {
+            continue;
+        }
+        const value = answerToText(field, shown[key], words, fieldTypes);
+        if (!value.trim()) {
+            continue;
+        }
+        rows.push({
+            key,
+            label: getRowLabel(field, key),
+            value
+        });
+    }
+    return rows;
+}
+function chosenAttributes(field, value) {
+    const options = getOptions(field);
+    const chosen = toStringList(value).map((v)=>options.find((o)=>String(o.value) === v)).filter(Boolean);
+    const out = {};
+    for (const option of chosen){
+        for (const [name, attr] of Object.entries(option.attributes || {})){
+            if (attr === null || attr === undefined) {
+                continue;
+            }
+            out[name] = out[name] ? `${out[name]}, ${String(attr)}` : String(attr);
+        }
+    }
+    return out;
+}
+/** Token values for a form's shown answers: `{{key}}`, `{{key.attribute}}` plus `extra`. */ export function buildTemplateValues(form, answers, extra = {}, fieldTypes) {
+    const { answers: shown } = getVisibility(form, answers);
+    const words = fillWords(form.wording);
+    const values = {
+        formTitle: form.title || '',
+        ...extra
+    };
+    for (const { field, key } of getInputFields(form)){
+        if (!(key in shown)) {
+            continue;
+        }
+        values[key] = answerToText(field, shown[key], words, fieldTypes);
+        if (isChoiceBlock(field)) {
+            for (const [name, attr] of Object.entries(chosenAttributes(field, shown[key]))){
+                values[`${key}.${name}`] = attr;
+            }
+        }
+    }
+    return values;
+}
+
+//# sourceMappingURL=tokens.js.map