@marktiderman/genesis-forms 0.8.0 → 0.9.0

package/dist/testing.js

@@ -1,3 +1,42 @@
+// src/props-check.ts
+var RESERVED_NAMES = new Set(Object.getOwnPropertyNames(Object.prototype));
+var isPlainRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isWholeNumber = (v) => typeof v === "number" && Number.isInteger(v);
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+function propsChecker(prefix, report) {
+  const at = (path) => path ? `${prefix}.${path}` : prefix;
+  const issue = (path, message) => report(at(path), message);
+  return {
+    issue,
+    text(v, path, nonEmpty = false) {
+      if (typeof v !== "string" || nonEmpty && !v) issue(path, nonEmpty ? "Required." : "Required text.");
+    },
+    optionalText(v, path) {
+      if (v !== void 0 && typeof v !== "string") issue(path, "Must be text.");
+    },
+    optionalBoolean(v, path) {
+      if (v !== void 0 && typeof v !== "boolean") issue(path, "Must be true or false.");
+    },
+    optionalInt(v, path, floor) {
+      if (v !== void 0 && !(isWholeNumber(v) && v >= floor)) issue(path, `Must be a whole number of ${floor} or more.`);
+    },
+    ordered(low, high, path, what) {
+      if (isWholeNumber(low) && isWholeNumber(high) && low > high) issue(path, `Can't be more than the ${what}.`);
+    },
+    name(v, path, what) {
+      if (typeof v !== "string" || !v) {
+        issue(path, `${what} must be a non-empty string.`);
+        return false;
+      }
+      if (RESERVED_NAMES.has(v)) {
+        issue(path, `"${v}" is reserved and cannot be used as ${what.toLowerCase()}.`);
+        return false;
+      }
+      return true;
+    }
+  };
+}
+
 // src/formula.ts
 var FORMULA_FUNCTIONS = ["sum", "avg", "min", "max"];
 var MAX_FORMULA_LENGTH = 2e3;
@@ -532,6 +571,17 @@ var calculatedFieldType = {
   value: { json: true },
   operators: numberOps,
   a11y: { semantics: "control" },
+  // A number, unless the format says text; without a format it can hold either, so it isn't known.
+  literal: (props) => props.format === "text" ? "string" : props.format === "number" || props.format === "percent" ? "number" : void 0,
+  // The formula itself is checked once every key is known (`parseForm`).
+  checkProps: (props, check) => {
+    if (props.format !== void 0 && props.format !== "number" && props.format !== "percent" && props.format !== "text") {
+      check.issue("format", "Must be number, percent or text.");
+    }
+    if (props.decimals !== void 0 && !(isWholeNumber(props.decimals) && props.decimals >= 0 && props.decimals <= MAX_CALCULATED_DECIMALS)) {
+      check.issue("decimals", `Must be a whole number from 0 to ${MAX_CALCULATED_DECIMALS}.`);
+    }
+  },
   // The engine works the value out; any number, text or true / false it made is valid.
   validate: (value) => typeof value === "number" || typeof value === "string" || typeof value === "boolean" ? null : "This value is worked out from other answers.",
   summarize: (value, field) => formatCalculated(value, field)
@@ -589,12 +639,42 @@ var MAX_HIGHLIGHT_NOTE_LENGTH = 1e3;
 var MAX_HIGHLIGHT_QUOTE_LENGTH = 2e3;
 var HIGHLIGHT_NOTE_MESSAGE = "Add a note to each highlight.";
 var sourceText = (field) => typeof field.props?.text === "string" && field.props.text ? field.props.text : void 0;
+var listProps = (props, check) => {
+  check.optionalInt(props.min, "min", 0);
+  check.optionalInt(props.max, "max", 1);
+  check.optionalInt(props.itemMaxLength, "itemMaxLength", 1);
+  check.optionalText(props.placeholder, "placeholder");
+  check.ordered(props.min, props.max ?? 10, "min", "most items");
+};
+var tableProps = (props, check) => {
+  const columns = props.columns;
+  if (!Array.isArray(columns) || columns.length < 1 || columns.length > MAX_TABLE_COLUMNS) {
+    check.issue("columns", `Must be a list of 1 to ${MAX_TABLE_COLUMNS} columns.`);
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    columns.forEach((c, j) => {
+      const at = `columns[${j}]`;
+      if (!isPlainRecord(c)) return check.issue(at, "Each column needs a key and a label.");
+      if (check.name(c.key, `${at}.key`, "A column key")) {
+        if (seen.has(c.key)) check.issue(`${at}.key`, `Duplicate column key "${c.key}".`);
+        seen.add(c.key);
+      }
+      check.text(c.label, `${at}.label`);
+      check.optionalBoolean(c.long, `${at}.long`);
+    });
+  }
+  check.optionalInt(props.minRows, "minRows", 0);
+  check.optionalInt(props.maxRows, "maxRows", 1);
+  check.ordered(props.minRows, props.maxRows ?? 3, "minRows", "most rows");
+};
 var structuredFieldTypes = [
   {
     type: "list",
     label: "List",
     category: "text",
     value: { json: true },
+    literal: "string",
+    checkProps: listProps,
     // logic.ts `contains` on an array is exact item equality, same as multi-choice, so it is offered.
     operators: ["contains", "answered", "empty"],
     a11y: { semantics: "group" },
@@ -620,6 +700,7 @@ var structuredFieldTypes = [
     label: "Table",
     category: "advanced",
     value: { json: true },
+    checkProps: tableProps,
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, (r) => isObject(r) && Object.values(r).every(blankText)),
@@ -663,6 +744,10 @@ var structuredFieldTypes = [
     label: "Notes at moments",
     category: "media",
     value: { json: true },
+    checkProps: (props, check) => {
+      check.optionalInt(props.maxNotes, "maxNotes", 1);
+      check.optionalInt(props.textMaxLength, "textMaxLength", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, (n) => isObject(n) && blankText(n.text)),
@@ -686,6 +771,10 @@ var structuredFieldTypes = [
     label: "Highlights",
     category: "media",
     value: { json: true },
+    checkProps: (props, check) => {
+      check.optionalText(props.text, "text");
+      check.optionalInt(props.maxHighlights, "maxHighlights", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, () => false),
@@ -777,6 +866,22 @@ var photoFieldType = {
   value: { json: true },
   operators: ["answered", "empty"],
   a11y: { semantics: "group" },
+  checkProps: (props, check) => {
+    if (props.maxFiles !== void 0 && !(isWholeNumber(props.maxFiles) && props.maxFiles >= 1 && props.maxFiles <= MAX_PHOTO_FILES)) {
+      check.issue("maxFiles", `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
+    }
+    if (props.maxSizeMb !== void 0 && !(isWholeNumber(props.maxSizeMb) && props.maxSizeMb >= 1 && props.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
+      check.issue("maxSizeMb", `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
+    }
+    if (props.formats !== void 0) {
+      const formats = props.formats;
+      if (!Array.isArray(formats) || formats.length === 0 || !formats.every(isPhotoFormat)) {
+        check.issue("formats", "Must be a list of one or more of jpeg, png, heic and webp.");
+      } else if (new Set(formats).size !== formats.length) {
+        check.issue("formats", "Name each format once.");
+      }
+    }
+  },
   isEmpty: (value) => value === void 0 || value === null || Array.isArray(value) && value.length === 0,
   validate: (value, field) => {
     if (!Array.isArray(value) || !value.every(isPhotoRef)) return "Add a photo.";
@@ -794,22 +899,59 @@ var photoFieldType = {
 };
 
 // src/fields.ts
-var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
+var VALIDATOR_FAILED_MESSAGE = "This answer couldn't be checked.";
+var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types@2");
+var BUILT_IN = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/built-in-field-types@2");
 var globalScope = globalThis;
 var registry = globalScope[REGISTRY] ??= /* @__PURE__ */ new Map();
-function registerFieldType(manifest) {
-  if (!manifest.type) throw new Error("registerFieldType: a field type needs a `type`.");
-  const value = manifest.value;
-  if (!value.json && (typeof value.serialize !== "function" || typeof value.deserialize !== "function")) {
-    throw new Error(
-      `registerFieldType: "${manifest.type}" stores a non-JSON value, so it must provide both serialize and deserialize.`
-    );
+var builtIn = globalScope[BUILT_IN] ??= /* @__PURE__ */ new Set();
+var freezeRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.freeze({ ...v }) : v;
+function frozen(manifest) {
+  const copy = { ...manifest };
+  for (const key of ["choice", "a11y", "value"]) if (key in copy) copy[key] = freezeRecord(copy[key]);
+  if (Array.isArray(copy.operators)) {
+    const operators = Object.freeze([...copy.operators]);
+    Object.defineProperty(copy, "operators", { get: () => [...operators], enumerable: true });
   }
-  registry.set(manifest.type, manifest);
+  return Object.freeze(copy);
+}
+function registerBuiltIn(manifest) {
+  builtIn.add(manifest.type);
+  if (!registry.has(manifest.type)) registry.set(manifest.type, frozen(manifest));
 }
 function getFieldType(type) {
   return registry.get(type);
 }
+function choiceKind(type) {
+  return registry.get(type)?.choice;
+}
+function isChoiceField(block) {
+  return !!block && block.kind === "field" && typeof block.type === "string" && choiceKind(block.type) !== void 0;
+}
+function literalType(type, props) {
+  const literal = registry.get(type)?.literal;
+  if (typeof literal !== "function") return literal;
+  try {
+    return literal(props);
+  } catch {
+    return void 0;
+  }
+}
+var CONTENT_REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/content-types@1");
+var contentScope = globalThis;
+var contentRegistry = contentScope[CONTENT_REGISTRY] ??= /* @__PURE__ */ new Map();
+function getContentType(type) {
+  return contentRegistry.get(type);
+}
+function listContentTypes() {
+  return [...contentRegistry.values()];
+}
+for (const manifest of [
+  { type: "heading", label: "Heading" },
+  { type: "text", label: "Text" }
+]) {
+  if (!contentRegistry.has(manifest.type)) contentRegistry.set(manifest.type, frozen(manifest));
+}
 function isEmptyValue(value, field) {
   const manifest = field ? registry.get(field.type) : void 0;
   if (manifest?.isEmpty) return manifest.isEmpty(value);
@@ -992,6 +1134,18 @@ function isPhoneNumber(value) {
   }
   return digits >= 7 && digits <= 15;
 }
+var oneOptionValidate = (value, field) => typeof value === "string" && (choiceOptions(field).some((o) => o.value === value) || typedOther(field, value)) ? null : "Choose one of the options.";
+var oneOptionSummary = (value, field) => optionLabel(field, String(value));
+var optionsValidate = (value, field) => {
+  const allowed = new Set(choiceOptions(field).map((o) => o.value));
+  const others = Array.isArray(value) ? value.filter((v) => typeof v === "string" && !allowed.has(v)) : [];
+  return Array.isArray(value) && new Set(value).size === value.length && value.every((v) => typeof v === "string") && (others.length === 0 || others.length === 1 && typedOther(field, others[0])) ? null : "Choose from the options.";
+};
+var optionsSummary = (value, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, String(v))).join(", ") : String(value);
+var scaleProps = (props, check) => {
+  check.optionalText(props.lowLabel, "lowLabel");
+  check.optionalText(props.highLabel, "highLabel");
+};
 var builtins = [
   {
     type: "short-text",
@@ -1000,6 +1154,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(500)
   },
   {
@@ -1009,6 +1164,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(5e3)
   },
   {
@@ -1018,6 +1174,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control", autocomplete: "email", inputMode: "email" },
+    literal: "string",
     validate: (value) => typeof value === "string" && isEmailAddress(value.trim()) ? null : "Enter an email address like name@example.com.",
     normalize: (value) => typeof value === "string" ? value.trim() : value
   },
@@ -1028,6 +1185,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "control", autocomplete: "tel", inputMode: "tel" },
+    literal: "string",
     validate: (value) => typeof value === "string" && isPhoneNumber(value.trim()) ? null : "Enter a phone number with 7 to 15 digits.",
     normalize: (value) => typeof value === "string" ? value.trim() : value,
     summarize: (value) => String(value)
@@ -1039,6 +1197,13 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "group" },
+    literal: "number",
+    checkProps: (props, check) => {
+      scaleProps(props, check);
+      if (props.display !== void 0 && props.display !== "numbers" && props.display !== "stars") {
+        check.issue("display", "Must be numbers or stars.");
+      }
+    },
     validate: (value, field) => {
       const { min, max } = intRange(field, 1, 5);
       return Number.isInteger(value) && value >= min && value <= max ? null : `Choose a rating from ${min} to ${max}.`;
@@ -1056,6 +1221,8 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "group" },
+    literal: "number",
+    checkProps: scaleProps,
     validate: (value) => Number.isInteger(value) && value >= 0 && value <= 10 ? null : "Choose a score from 0 to 10.",
     summarize: (value, field) => {
       const end = scaleEndLabel(field, value, 0, 10);
@@ -1069,8 +1236,10 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field) => typeof value === "string" && (choiceOptions(field).some((o) => o.value === value) || typedOther(field, value)) ? null : "Choose one of the options.",
-    summarize: (value, field) => optionLabel(field, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "multi-choice",
@@ -1079,12 +1248,10 @@ var builtins = [
     value: { json: true },
     operators: ["contains", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field) => {
-      const allowed = new Set(choiceOptions(field).map((o) => o.value));
-      const others = Array.isArray(value) ? value.filter((v) => typeof v === "string" && !allowed.has(v)) : [];
-      return Array.isArray(value) && new Set(value).size === value.length && value.every((v) => typeof v === "string") && (others.length === 0 || others.length === 1 && typedOther(field, others[0])) ? null : "Choose from the options.";
-    },
-    summarize: (value, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, String(v))).join(", ") : String(value)
+    literal: "string",
+    choice: { multiple: true },
+    validate: optionsValidate,
+    summarize: optionsSummary
   },
   {
     type: "yes-no",
@@ -1093,6 +1260,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "group" },
+    literal: "boolean",
     validate: (value) => typeof value === "boolean" ? null : "Choose yes or no.",
     summarize: (value) => value ? "Yes" : "No"
   },
@@ -1103,8 +1271,10 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "control" },
-    validate: (value, field) => typeof value === "string" && (choiceOptions(field).some((o) => o.value === value) || typedOther(field, value)) ? null : "Choose one of the options.",
-    summarize: (value, field) => optionLabel(field, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "number",
@@ -1113,6 +1283,16 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "control", inputMode: "decimal" },
+    literal: "number",
+    checkProps: (props, check) => {
+      for (const k of ["min", "max", "step"]) {
+        if (props[k] !== void 0 && !isFiniteNumber(props[k])) check.issue(k, "Must be a number.");
+      }
+      if (isFiniteNumber(props.step) && props.step <= 0) check.issue("step", "Must be above 0.");
+      if (isFiniteNumber(props.min) && isFiniteNumber(props.max) && props.min > props.max) {
+        check.issue("min", "Can't be more than the largest number.");
+      }
+    },
     validate: (value, field) => {
       if (typeof value !== "number" || !Number.isFinite(value)) return "Enter a number.";
       const { min, max, step } = numberLimits(field);
@@ -1139,6 +1319,17 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "control" },
+    literal: "string",
+    checkProps: (props, check) => {
+      for (const k of ["min", "max"]) {
+        if (props[k] !== void 0 && !(typeof props[k] === "string" && isIsoDate(props[k]))) {
+          check.issue(k, "Must be a date like 2026-10-22.");
+        }
+      }
+      if (typeof props.min === "string" && typeof props.max === "string" && isIsoDate(props.min) && isIsoDate(props.max) && props.min > props.max) {
+        check.issue("min", "Can't be after the latest date.");
+      }
+    },
     validate: (value, field) => {
       if (typeof value !== "string" || !isIsoDate(value.trim())) return "Enter a date like 2026-10-22.";
       const date = value.trim();
@@ -1161,6 +1352,8 @@ var builtins = [
     value: { json: true },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
+    literal: "boolean",
+    checkProps: (props, check) => check.optionalText(props.text, "text"),
     // Unchecked is unanswered, so a required consent must be checked.
     isEmpty: (value) => value === void 0 || value === null || value === false,
     validate: (value) => value === true ? null : "Check the box to agree.",
@@ -1210,7 +1403,7 @@ function dateLimits(field) {
   if (typeof max === "string" && isIsoDate(max)) out.max = max;
   return out;
 }
-for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType, photoFieldType]) registerFieldType(manifest);
+for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType, photoFieldType]) registerBuiltIn(manifest);
 
 // src/events.ts
 function isPlainObject(value) {
@@ -1427,8 +1620,8 @@ function fieldMap(def) {
 }
 
 // src/options.ts
-var CHOICE_FIELD_TYPES = /* @__PURE__ */ new Set(["single-choice", "multi-choice", "dropdown"]);
-var isChoice = (block) => !!block && block.kind === "field" && CHOICE_FIELD_TYPES.has(block.type);
+var isChoice = isChoiceField;
+var isMultiple = (field) => choiceKind(field.type)?.multiple === true;
 function put(record, key, value) {
   Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
 }
@@ -1506,7 +1699,7 @@ function isPrefillParam(param) {
   return typeof param === "string" && param.length <= MAX_PREFILL_PARAM_LENGTH && /^[A-Za-z0-9_.-]+$/.test(param);
 }
 function prefillSetting(field) {
-  if (!CHOICE_FIELD_TYPES.has(field.type)) return void 0;
+  if (!choiceKind(field.type)) return void 0;
   const raw = field.props?.prefill;
   if (!raw || typeof raw !== "object" || Array.isArray(raw) || !isPrefillParam(raw.param)) return void 0;
   return { param: raw.param, hideWhenPrefilled: raw.hideWhenPrefilled === true };
@@ -1534,7 +1727,7 @@ function prefillFromLink(definition, params, values = {}) {
     if (!raw.length) continue;
     const shown2 = new Set(visibleOptions(definition, block, seen).map((o) => o.value));
     let value;
-    if (block.type === "multi-choice") {
+    if (isMultiple(block)) {
       const picked = [];
       for (const r of raw) {
         for (const v of shown2.has(r) ? [r] : r.split(",").map((s) => s.trim())) {
@@ -1605,8 +1798,13 @@ function validateField(field, value, options = {}) {
   }
   const manifest = getFieldType(field.type);
   if (!manifest) return `Unknown field type "${field.type}".`;
-  const builtIn = manifest.validate?.(value, field) ?? null;
-  if (builtIn) return builtIn;
+  let builtIn2;
+  try {
+    builtIn2 = manifest.validate?.(value, field) ?? null;
+  } catch {
+    builtIn2 = VALIDATOR_FAILED_MESSAGE;
+  }
+  if (builtIn2) return builtIn2;
   return options.custom ? runCustom(options.custom, value) : null;
 }
 
@@ -2090,25 +2288,6 @@ function shown(v) {
 }
 var isObject2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var isInt = (v) => typeof v === "number" && Number.isInteger(v);
-var LITERAL_TYPE = {
-  "short-text": "string",
-  "long-text": "string",
-  email: "string",
-  phone: "string",
-  rating: "number",
-  nps: "number",
-  "single-choice": "string",
-  "multi-choice": "string",
-  "yes-no": "boolean",
-  list: "string",
-  dropdown: "string",
-  number: "number",
-  date: "string",
-  consent: "boolean",
-  // A calculated field holds a number unless its format says text; see `literalType`.
-  calculated: "number"
-};
-var CHOICE_TYPES = /* @__PURE__ */ new Set(["single-choice", "multi-choice", "dropdown"]);
 var ORDERING = /* @__PURE__ */ new Set(["lt", "lte", "gt", "gte"]);
 var OPERATORS = /* @__PURE__ */ new Set([
   "eq",
@@ -2122,8 +2301,11 @@ var OPERATORS = /* @__PURE__ */ new Set([
   "answered",
   "empty"
 ]);
-var RESERVED = new Set(Object.getOwnPropertyNames(Object.prototype));
 var MAX_CONDITION_DEPTH = 32;
+function contentKinds() {
+  const names = listContentTypes().map((c) => c.type);
+  return names.length > 1 ? `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}` : names[0] ?? "a registered content type";
+}
 function parseForm(input) {
   const issues = [];
   const warnings = [];
@@ -2153,7 +2335,7 @@ function parseForm(input) {
     }
     const fits = (x) => typeof x === "string" && x.length <= OPTION_LIMITS.attributeValue;
     for (const [name2, v] of Object.entries(attributes)) {
-      if (!name2.trim() || name2.length > OPTION_LIMITS.attributeName || RESERVED.has(name2)) {
+      if (!name2.trim() || name2.length > OPTION_LIMITS.attributeName || RESERVED_NAMES.has(name2)) {
         issue(`${at}.attributes`, `${shown(name2)} isn't a usable attribute name (at most ${OPTION_LIMITS.attributeName} characters).`);
       } else if (!fits(v) && !(Array.isArray(v) && v.length <= OPTION_LIMITS.attributeItems && v.every(fits))) {
         issue(
@@ -2168,104 +2350,18 @@ function parseForm(input) {
       issue(path, `${what} must be a non-empty string.`);
       return false;
     }
-    if (RESERVED.has(v)) {
+    if (RESERVED_NAMES.has(v)) {
       issue(path, `"${v}" is reserved and cannot be used as ${what.toLowerCase()}.`);
       return false;
     }
     return true;
   };
-  const optionalInt = (v, path, floor) => {
-    if (v !== void 0 && !(isInt(v) && v >= floor)) issue(path, `Must be a whole number of ${floor} or more.`);
-  };
-  const ordered = (low, high, path, what) => {
-    if (isInt(low) && isInt(high) && low > high) issue(path, `Can't be more than the ${what}.`);
-  };
-  const structuredProps = (type, props, path) => {
-    if (type === "list") {
-      optionalInt(props.min, `${path}.min`, 0);
-      optionalInt(props.max, `${path}.max`, 1);
-      optionalInt(props.itemMaxLength, `${path}.itemMaxLength`, 1);
-      optionalText(props.placeholder, `${path}.placeholder`);
-      ordered(props.min, props.max ?? 10, `${path}.min`, "most items");
-    } else if (type === "table") {
-      const columns = props.columns;
-      if (!Array.isArray(columns) || columns.length < 1 || columns.length > MAX_TABLE_COLUMNS) {
-        issue(`${path}.columns`, `Must be a list of 1 to ${MAX_TABLE_COLUMNS} columns.`);
-      } else {
-        const seen = /* @__PURE__ */ new Set();
-        columns.forEach((c, j) => {
-          const at = `${path}.columns[${j}]`;
-          if (!isObject2(c)) return issue(at, "Each column needs a key and a label.");
-          if (name(c.key, `${at}.key`, "A column key")) {
-            if (seen.has(c.key)) issue(`${at}.key`, `Duplicate column key "${c.key}".`);
-            seen.add(c.key);
-          }
-          text(c.label, `${at}.label`);
-          optionalBoolean(c.long, `${at}.long`);
-        });
-      }
-      optionalInt(props.minRows, `${path}.minRows`, 0);
-      optionalInt(props.maxRows, `${path}.maxRows`, 1);
-      ordered(props.minRows, props.maxRows ?? 3, `${path}.minRows`, "most rows");
-    } else if (type === "media-notes") {
-      optionalInt(props.maxNotes, `${path}.maxNotes`, 1);
-      optionalInt(props.textMaxLength, `${path}.textMaxLength`, 1);
-    } else if (type === "text-highlights") {
-      optionalText(props.text, `${path}.text`);
-      optionalInt(props.maxHighlights, `${path}.maxHighlights`, 1);
-    } else if (type === CALCULATED_TYPE) {
-      if (props.format !== void 0 && props.format !== "number" && props.format !== "percent" && props.format !== "text") {
-        issue(`${path}.format`, "Must be number, percent or text.");
-      }
-      if (props.decimals !== void 0 && !(isInt(props.decimals) && props.decimals >= 0 && props.decimals <= MAX_CALCULATED_DECIMALS)) {
-        issue(`${path}.decimals`, `Must be a whole number from 0 to ${MAX_CALCULATED_DECIMALS}.`);
-      }
-    }
-  };
-  const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
-  const fieldProps = (type, props, path) => {
-    if (type === "rating" || type === "nps") {
-      optionalText(props.lowLabel, `${path}.lowLabel`);
-      optionalText(props.highLabel, `${path}.highLabel`);
-    }
-    if (type === "rating" && props.display !== void 0 && props.display !== "numbers" && props.display !== "stars") {
-      issue(`${path}.display`, "Must be numbers or stars.");
-    }
-    if (type === "number") {
-      for (const k of ["min", "max", "step"]) {
-        if (props[k] !== void 0 && !isFiniteNumber(props[k])) issue(`${path}.${k}`, "Must be a number.");
-      }
-      if (isFiniteNumber(props.step) && props.step <= 0) issue(`${path}.step`, "Must be above 0.");
-      if (isFiniteNumber(props.min) && isFiniteNumber(props.max) && props.min > props.max) {
-        issue(`${path}.min`, "Can't be more than the largest number.");
-      }
-    }
-    if (type === "date") {
-      for (const k of ["min", "max"]) {
-        if (props[k] !== void 0 && !(typeof props[k] === "string" && isIsoDate(props[k]))) {
-          issue(`${path}.${k}`, "Must be a date like 2026-10-22.");
-        }
-      }
-      if (typeof props.min === "string" && typeof props.max === "string" && isIsoDate(props.min) && isIsoDate(props.max) && props.min > props.max) {
-        issue(`${path}.min`, "Can't be after the latest date.");
-      }
-    }
-    if (type === "consent") optionalText(props.text, `${path}.text`);
-    if (type === PHOTO_TYPE) {
-      if (props.maxFiles !== void 0 && !(isInt(props.maxFiles) && props.maxFiles >= 1 && props.maxFiles <= MAX_PHOTO_FILES)) {
-        issue(`${path}.maxFiles`, `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
-      }
-      if (props.maxSizeMb !== void 0 && !(isInt(props.maxSizeMb) && props.maxSizeMb >= 1 && props.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
-        issue(`${path}.maxSizeMb`, `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
-      }
-      if (props.formats !== void 0) {
-        const formats = props.formats;
-        if (!Array.isArray(formats) || formats.length === 0 || !formats.every(isPhotoFormat)) {
-          issue(`${path}.formats`, "Must be a list of one or more of jpeg, png, heic and webp.");
-        } else if (new Set(formats).size !== formats.length) {
-          issue(`${path}.formats`, "Name each format once.");
-        }
-      }
+  const kindProps = (check, props, path) => {
+    if (!check) return;
+    try {
+      check(props, propsChecker(path, issue));
+    } catch {
+      issue(path, "These settings couldn't be checked.");
     }
   };
   if (!isObject2(input)) {
@@ -2304,7 +2400,7 @@ function parseForm(input) {
   const order = /* @__PURE__ */ new Map();
   const tableColumnKeys = /* @__PURE__ */ new Map();
   const choices = /* @__PURE__ */ new Map();
-  const calculatedLiteral = /* @__PURE__ */ new Map();
+  const literals = /* @__PURE__ */ new Map();
   input.blocks.forEach((block, i) => {
     const path = `blocks[${i}]`;
     if (!isObject2(block) || typeof block.id !== "string" || !block.id) {
@@ -2332,7 +2428,7 @@ function parseForm(input) {
         if (from !== void 0) {
           if (!isObject2(from) || from.source !== "host" || typeof from.key !== "string" || !from.key) {
             issue(`${path}.props.optionsFrom`, 'Must be { source: "host", key } with a non-empty key.');
-          } else if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+          } else if (typeof block.type === "string" && !choiceKind(block.type)) {
             warnings.push({ path: `${path}.props.optionsFrom`, message: "Only single choice, multiple choice and dropdown questions take options from the app." });
           }
           const filter = isObject2(from) ? from.filter : void 0;
@@ -2354,7 +2450,7 @@ function parseForm(input) {
             );
           } else {
             optionalBoolean(prefill.hideWhenPrefilled, `${path}.props.prefill.hideWhenPrefilled`);
-            if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+            if (typeof block.type === "string" && !choiceKind(block.type)) {
               warnings.push({ path: `${path}.props.prefill`, message: "Only single choice, multiple choice and dropdown questions are filled in from a link." });
             }
           }
@@ -2385,7 +2481,7 @@ function parseForm(input) {
         if (other !== void 0) {
           if (other !== true && other !== false && !(isObject2(other) && (other.label === void 0 || typeof other.label === "string"))) {
             issue(`${path}.props.other`, "Must be true, false or { label }.");
-          } else if (other !== false && typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+          } else if (other !== false && typeof block.type === "string" && !choiceKind(block.type)) {
             warnings.push({ path: `${path}.props.other`, message: 'Only single choice, multiple choice and dropdown questions take an "Other" answer.' });
           }
         }
@@ -2398,19 +2494,14 @@ function parseForm(input) {
         }
       }
       if (typeof block.type === "string" && (block.props === void 0 || isObject2(block.props))) {
-        structuredProps(block.type, block.props ?? {}, `${path}.props`);
-        fieldProps(block.type, block.props ?? {}, `${path}.props`);
+        kindProps(getFieldType(block.type)?.checkProps, block.props ?? {}, `${path}.props`);
       }
       if (validKey) {
         if (keys.has(block.key)) issue(`${path}.key`, `Duplicate key "${String(block.key)}".`);
         keys.set(block.key, block.id);
       }
       fieldTypes.set(block.id, typeof block.type === "string" ? block.type : "");
-      if (block.type === CALCULATED_TYPE) {
-        const format = isObject2(block.props) ? block.props.format : void 0;
-        if (format === "text") calculatedLiteral.set(block.id, "string");
-        else if (format !== "number" && format !== "percent") calculatedLiteral.set(block.id, void 0);
-      }
+      literals.set(block.id, typeof block.type === "string" ? literalType(block.type, isObject2(block.props) ? block.props : {}) : void 0);
       if (block.type === "table" && isObject2(block.props) && Array.isArray(block.props.columns)) {
         tableColumnKeys.set(
           block.id,
@@ -2418,8 +2509,13 @@ function parseForm(input) {
         );
       }
     } else if (block.kind === "content") {
-      if (block.type !== "heading" && block.type !== "text") issue(`${path}.type`, "Must be heading or text.");
+      const content = typeof block.type === "string" ? getContentType(block.type) : void 0;
+      if (!content) issue(`${path}.type`, `Must be ${contentKinds()}.`);
       text(block.text, `${path}.text`);
+      if (content?.checkProps) {
+        if (block.props === void 0 || isObject2(block.props) && isJson(block.props)) kindProps(content.checkProps, block.props ?? {}, `${path}.props`);
+        else issue(`${path}.props`, "Must be a JSON object.");
+      }
     } else if (block.kind === "page-break") {
       optionalText(block.title, `${path}.title`);
     } else {
@@ -2549,8 +2645,8 @@ function parseForm(input) {
     if (typeof left.field === "string" && fieldTypes.has(left.field)) {
       const fieldType = fieldTypes.get(left.field);
       what = `"${keyOf(left.field)}"`;
-      type = calculatedLiteral.has(left.field) ? calculatedLiteral.get(left.field) : LITERAL_TYPE[fieldType];
-      if (CHOICE_TYPES.has(fieldType)) options = choices.get(left.field);
+      type = literals.get(left.field);
+      if (choiceKind(fieldType)) options = choices.get(left.field);
     } else if (typeof left.hidden === "string" && hiddenTypes.has(left.hidden)) {
       what = `hidden input "${left.hidden}"`;
       type = hiddenTypes.get(left.hidden);