@form-engine-ts/core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,790 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  aggregateResponses: () => aggregateResponses,
+  assertValidFormSchema: () => assertValidFormSchema,
+  calculateChoiceDistribution: () => calculateChoiceDistribution,
+  calculateFieldVisibility: () => calculateFieldVisibility,
+  calculateNumericSummary: () => calculateNumericSummary,
+  createSubmission: () => createSubmission,
+  escapeCsvCell: () => escapeCsvCell,
+  exportResponsesToCsv: () => exportResponsesToCsv,
+  isQuestionVisible: () => isQuestionVisible,
+  resolveFormTranslation: () => resolveFormTranslation,
+  sanitizeSchema: () => sanitizeSchema,
+  selectVisibleAnswers: () => selectVisibleAnswers,
+  validateAnswers: () => validateAnswers,
+  validateFormSchema: () => validateFormSchema,
+  validateSchemaStructure: () => validateSchemaStructure
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sanitization.ts
+function cyclicQuestionIds(fields) {
+  const firstById = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    if (!firstById.has(field.id)) firstById.set(field.id, field);
+  }
+  const cyclic = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Set();
+  for (const startId of firstById.keys()) {
+    if (resolved.has(startId)) continue;
+    const path = [];
+    const pathIndex = /* @__PURE__ */ new Map();
+    let currentId = startId;
+    while (currentId !== void 0 && firstById.has(currentId) && !resolved.has(currentId)) {
+      const existingIndex = pathIndex.get(currentId);
+      if (existingIndex !== void 0) {
+        for (const id of path.slice(existingIndex)) cyclic.add(id);
+        break;
+      }
+      pathIndex.set(currentId, path.length);
+      path.push(currentId);
+      const field = firstById.get(currentId);
+      const sourceId = field?.displayCondition?.questionId;
+      currentId = sourceId === currentId ? void 0 : sourceId;
+    }
+    for (const id of path) resolved.add(id);
+  }
+  return cyclic;
+}
+function validateSchemaStructure(schema) {
+  const issues = [];
+  const questionIds = /* @__PURE__ */ new Set();
+  for (const field of schema.fields) {
+    if (questionIds.has(field.id)) {
+      issues.push({
+        type: "duplicate_question_id",
+        questionId: field.id,
+        message: `Question ID "${field.id}" is duplicated.`
+      });
+    } else {
+      questionIds.add(field.id);
+    }
+    if (!("options" in field) || !Array.isArray(field.options)) continue;
+    const choiceIds = /* @__PURE__ */ new Set();
+    for (const option of field.options) {
+      if (choiceIds.has(option.id)) {
+        issues.push({
+          type: "duplicate_choice_id",
+          questionId: field.id,
+          choiceId: option.id,
+          message: `Choice ID "${option.id}" is duplicated in question "${field.id}".`
+        });
+      } else {
+        choiceIds.add(option.id);
+      }
+    }
+  }
+  for (const field of schema.fields) {
+    const sourceId = field.displayCondition?.questionId;
+    if (sourceId === void 0) continue;
+    if (sourceId === field.id) {
+      issues.push({
+        type: "self_condition_reference",
+        questionId: field.id,
+        message: `Question "${field.id}" cannot depend on itself.`
+      });
+    } else if (!questionIds.has(sourceId)) {
+      issues.push({
+        type: "dangling_condition_reference",
+        questionId: field.id,
+        message: `Question "${field.id}" references missing question "${sourceId}".`
+      });
+    }
+  }
+  const cyclic = cyclicQuestionIds(schema.fields);
+  for (const field of schema.fields) {
+    if (!cyclic.has(field.id)) continue;
+    issues.push({
+      type: "cyclic_condition_reference",
+      questionId: field.id,
+      message: `Question "${field.id}" participates in a display-condition cycle.`
+    });
+  }
+  return issues;
+}
+function sanitizeSchema(schema) {
+  const existingQuestionIds = new Set(schema.fields.map((field) => field.id));
+  const cyclic = cyclicQuestionIds(schema.fields);
+  return {
+    ...schema,
+    fields: schema.fields.map((field) => {
+      const sourceId = field.displayCondition?.questionId;
+      if (sourceId === void 0 || existingQuestionIds.has(sourceId) && sourceId !== field.id && !cyclic.has(field.id)) {
+        return field;
+      }
+      const { displayCondition: _displayCondition, ...sanitized } = field;
+      return sanitized;
+    })
+  };
+}
+
+// src/schema.ts
+var FIELD_TYPES = /* @__PURE__ */ new Set(["text", "textarea", "number", "rating", "select", "multi-select", "checkbox", "radio"]);
+var CONDITION_OPERATORS = /* @__PURE__ */ new Set(["equals", "not_equals", "contains", "not_empty"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function issue(issues, path, code, message) {
+  issues.push({ path, code, message });
+}
+function rejectLegacyProperties(value, path, properties, issues) {
+  for (const property of properties) {
+    if (Object.hasOwn(value, property)) {
+      issue(
+        issues,
+        path.length === 0 ? property : `${path}.${property}`,
+        "legacy_property",
+        `${property} is not supported by the natural-language schema.`
+      );
+    }
+  }
+}
+function validateOptionalNonNegativeInteger(value, path, issues) {
+  if (value === void 0) return true;
+  if (!Number.isInteger(value) || value < 0) {
+    issue(issues, path, "invalid_bound", "Expected a non-negative integer.");
+    return false;
+  }
+  return true;
+}
+function validateOptions(value, path, issues) {
+  if (!Array.isArray(value) || value.length === 0) {
+    issue(issues, path, "invalid_options", "Expected at least one option.");
+    return false;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  value.forEach((option, index) => {
+    const optionPath = `${path}[${index}]`;
+    if (!isRecord(option)) {
+      issue(issues, optionPath, "invalid_option", "Expected an option object.");
+      return;
+    }
+    rejectLegacyProperties(option, optionPath, ["value", "labelKey"], issues);
+    if (!isNonEmptyString(option.id)) {
+      issue(issues, `${optionPath}.id`, "invalid_option_id", "Expected a non-empty option ID.");
+    } else if (seen.has(option.id)) {
+      issue(issues, `${optionPath}.id`, "duplicate_option", "Option IDs must be unique.");
+    } else {
+      seen.add(option.id);
+    }
+    if (!isNonEmptyString(option.label)) {
+      issue(issues, `${optionPath}.label`, "invalid_label", "Expected a non-empty option label.");
+    }
+  });
+  return true;
+}
+function validateDisplayCondition(value, path, issues) {
+  if (!isRecord(value)) {
+    issue(issues, path, "invalid_condition", "Expected a display condition object.");
+    return false;
+  }
+  if (!isNonEmptyString(value.questionId)) {
+    issue(issues, `${path}.questionId`, "invalid_condition_source", "Expected a question ID.");
+  }
+  if (typeof value.operator !== "string" || !CONDITION_OPERATORS.has(value.operator)) {
+    issue(issues, `${path}.operator`, "invalid_condition_operator", "Unsupported condition operator.");
+    return false;
+  }
+  const hasValue = Object.hasOwn(value, "value") && value.value !== void 0;
+  if (value.operator === "not_empty") {
+    if (hasValue) issue(issues, `${path}.value`, "unexpected_condition_value", "not_empty does not accept a value.");
+  } else if (!hasValue) {
+    issue(issues, `${path}.value`, "missing_condition_value", `${value.operator} requires a value.`);
+  } else if (!["string", "number", "boolean"].includes(typeof value.value)) {
+    issue(issues, `${path}.value`, "invalid_condition_value", "Expected a string, number, or boolean.");
+  } else if (typeof value.value === "number" && !Number.isFinite(value.value)) {
+    issue(issues, `${path}.value`, "invalid_condition_value", "Expected a finite number.");
+  }
+  return true;
+}
+function validateField(value, path, issues) {
+  if (!isRecord(value)) {
+    issue(issues, path, "invalid_field", "Expected a field object.");
+    return false;
+  }
+  rejectLegacyProperties(value, path, ["titleKey", "labelKey", "helpTextKey", "descriptionKey"], issues);
+  if (!isNonEmptyString(value.id)) issue(issues, `${path}.id`, "invalid_id", "Expected a non-empty ID.");
+  if (!isNonEmptyString(value.title)) {
+    issue(issues, `${path}.title`, "invalid_title", "Expected a non-empty question title.");
+  }
+  if (value.description !== void 0 && !isNonEmptyString(value.description)) {
+    issue(issues, `${path}.description`, "invalid_description", "Expected a non-empty question description.");
+  }
+  if (value.translationKey !== void 0 && !isNonEmptyString(value.translationKey)) {
+    issue(issues, `${path}.translationKey`, "invalid_translation_key", "Expected a translation key.");
+  }
+  if (typeof value.required !== "boolean") {
+    issue(issues, `${path}.required`, "invalid_required", "Expected a boolean.");
+  }
+  if (value.displayCondition !== void 0) {
+    validateDisplayCondition(value.displayCondition, `${path}.displayCondition`, issues);
+  }
+  if (typeof value.type !== "string" || !FIELD_TYPES.has(value.type)) {
+    issue(issues, `${path}.type`, "invalid_field_type", "Unsupported field type.");
+    return false;
+  }
+  if (value.type === "text" || value.type === "textarea") {
+    const minValid = validateOptionalNonNegativeInteger(value.minLength, `${path}.minLength`, issues);
+    const maxValid = validateOptionalNonNegativeInteger(value.maxLength, `${path}.maxLength`, issues);
+    if (minValid && maxValid && typeof value.minLength === "number" && typeof value.maxLength === "number" && value.minLength > value.maxLength) {
+      issue(issues, path, "contradictory_bounds", "minLength cannot exceed maxLength.");
+    }
+    if (value.pattern !== void 0) {
+      if (typeof value.pattern !== "string") {
+        issue(issues, `${path}.pattern`, "invalid_pattern", "Expected a regular expression string.");
+      } else {
+        try {
+          new RegExp(value.pattern);
+        } catch {
+          issue(issues, `${path}.pattern`, "invalid_pattern", "Regular expression is invalid.");
+        }
+      }
+    }
+  }
+  if (value.type === "number") {
+    for (const key of ["min", "max", "step"]) {
+      const bound = value[key];
+      if (bound !== void 0 && (typeof bound !== "number" || !Number.isFinite(bound))) {
+        issue(issues, `${path}.${key}`, "invalid_bound", "Expected a finite number.");
+      }
+    }
+    if (typeof value.step === "number" && value.step <= 0) {
+      issue(issues, `${path}.step`, "invalid_step", "step must be greater than zero.");
+    }
+    if (typeof value.min === "number" && typeof value.max === "number" && value.min > value.max) {
+      issue(issues, path, "contradictory_bounds", "min cannot exceed max.");
+    }
+  }
+  if (value.type === "rating") {
+    for (const key of ["min", "max"]) {
+      const bound = value[key];
+      if (bound !== void 0 && (!Number.isInteger(bound) || !Number.isFinite(bound))) {
+        issue(issues, `${path}.${key}`, "invalid_bound", "Expected a finite integer.");
+      }
+    }
+    const min = typeof value.min === "number" ? value.min : 1;
+    const max = typeof value.max === "number" ? value.max : 5;
+    if (min > max) issue(issues, path, "contradictory_bounds", "min cannot exceed max.");
+  }
+  if (value.type === "select" || value.type === "radio" || value.type === "multi-select") {
+    validateOptions(value.options, `${path}.options`, issues);
+  }
+  if (value.type === "multi-select") {
+    const minValid = validateOptionalNonNegativeInteger(value.minSelections, `${path}.minSelections`, issues);
+    const maxValid = validateOptionalNonNegativeInteger(value.maxSelections, `${path}.maxSelections`, issues);
+    if (minValid && maxValid && typeof value.minSelections === "number" && typeof value.maxSelections === "number" && value.minSelections > value.maxSelections) {
+      issue(issues, path, "contradictory_bounds", "minSelections cannot exceed maxSelections.");
+    }
+    if (Array.isArray(value.options) && typeof value.maxSelections === "number" && value.maxSelections > value.options.length) {
+      issue(issues, `${path}.maxSelections`, "invalid_bound", "maxSelections cannot exceed option count.");
+    }
+  }
+  return true;
+}
+function validateFormSchema(input) {
+  const issues = [];
+  if (!isRecord(input)) {
+    return { valid: false, issues: [{ path: "$", code: "invalid_schema", message: "Expected a schema object." }] };
+  }
+  rejectLegacyProperties(input, "", ["titleKey", "descriptionKey"], issues);
+  if (!isNonEmptyString(input.id)) issue(issues, "id", "invalid_id", "Expected a non-empty ID.");
+  if (!Number.isInteger(input.version) || input.version < 1) {
+    issue(issues, "version", "invalid_version", "Expected a positive integer version.");
+  }
+  if (!isNonEmptyString(input.title)) {
+    issue(issues, "title", "invalid_title", "Expected a non-empty form title.");
+  }
+  for (const key of ["description", "submitLabelKey"]) {
+    if (input[key] !== void 0 && !isNonEmptyString(input[key])) {
+      issue(
+        issues,
+        key,
+        key === "description" ? "invalid_description" : "invalid_translation_key",
+        key === "description" ? "Expected a non-empty form description." : "Expected a translation key."
+      );
+    }
+  }
+  if (!Array.isArray(input.fields) || input.fields.length === 0) {
+    issue(issues, "fields", "invalid_fields", "Expected at least one field.");
+  } else {
+    const inputFields = input.fields;
+    const ids = /* @__PURE__ */ new Set();
+    inputFields.forEach((field, index) => {
+      validateField(field, `fields[${index}]`, issues);
+      if (isRecord(field) && isNonEmptyString(field.id)) {
+        if (ids.has(field.id)) issue(issues, `fields[${index}].id`, "duplicate_field", "Field IDs must be unique.");
+        ids.add(field.id);
+      }
+    });
+    const structuralSchema = {
+      id: typeof input.id === "string" ? input.id : "invalid",
+      version: typeof input.version === "number" ? input.version : 1,
+      title: typeof input.title === "string" ? input.title : "invalid",
+      fields: inputFields.filter((field) => isRecord(field) && isNonEmptyString(field.id))
+    };
+    for (const structuralIssue of validateSchemaStructure(structuralSchema)) {
+      if (structuralIssue.type !== "dangling_condition_reference" && structuralIssue.type !== "self_condition_reference" && structuralIssue.type !== "cyclic_condition_reference") {
+        continue;
+      }
+      const fieldIndex = inputFields.findIndex((field) => isRecord(field) && field.id === structuralIssue.questionId);
+      const code = structuralIssue.type === "dangling_condition_reference" ? "unknown_condition_source" : structuralIssue.type === "self_condition_reference" ? "self_condition" : "condition_cycle";
+      issue(issues, `fields[${fieldIndex}].displayCondition`, code, structuralIssue.message);
+    }
+  }
+  return issues.length === 0 ? { valid: true, value: input, issues: [] } : { valid: false, issues };
+}
+function assertValidFormSchema(input) {
+  const result = validateFormSchema(input);
+  if (!result.valid) {
+    throw new TypeError(
+      `Invalid form schema: ${result.issues.map((item) => `${item.path}: ${item.message}`).join("; ")}`
+    );
+  }
+}
+
+// src/visibility.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "number") return !Number.isFinite(value);
+  return false;
+}
+function normalizeString(value) {
+  return value.trim().normalize("NFKC").toLowerCase();
+}
+function valuesEqual(left, right) {
+  return typeof left === "string" && typeof right === "string" ? normalizeString(left) === normalizeString(right) : left === right;
+}
+function isQuestionVisible(question, currentAnswers) {
+  const condition = question.displayCondition;
+  if (condition === void 0) return true;
+  const answer = currentAnswers[condition.questionId];
+  if (isEmpty(answer)) return false;
+  if (condition.operator === "not_empty") return true;
+  if (condition.value === void 0) return false;
+  if (condition.operator === "equals") return valuesEqual(answer, condition.value);
+  if (condition.operator === "not_equals") return !valuesEqual(answer, condition.value);
+  if (typeof answer === "string" && typeof condition.value === "string") {
+    return normalizeString(answer).includes(normalizeString(condition.value));
+  }
+  return Array.isArray(answer) && answer.some((item) => valuesEqual(item, condition.value));
+}
+function calculateFieldVisibility(schema, currentAnswers) {
+  const fields = new Map(schema.fields.map((field) => [field.id, field]));
+  const resolved = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  const resolve = (field) => {
+    const existing = resolved.get(field.id);
+    if (existing !== void 0) return existing;
+    if (resolving.has(field.id)) return false;
+    resolving.add(field.id);
+    const sourceId = field.displayCondition?.questionId;
+    const source = sourceId === void 0 ? void 0 : fields.get(sourceId);
+    const sourceVisible = source === void 0 ? sourceId === void 0 : resolve(source);
+    const visible = sourceVisible && isQuestionVisible(field, currentAnswers);
+    resolving.delete(field.id);
+    resolved.set(field.id, visible);
+    return visible;
+  };
+  for (const field of schema.fields) resolve(field);
+  return Object.freeze(Object.fromEntries(resolved));
+}
+function selectVisibleAnswers(schema, currentAnswers) {
+  const visibility = calculateFieldVisibility(schema, currentAnswers);
+  return Object.fromEntries(
+    schema.fields.filter((field) => visibility[field.id] === true && Object.hasOwn(currentAnswers, field.id)).map((field) => [field.id, currentAnswers[field.id]])
+  );
+}
+
+// src/analytics.ts
+function percentage(count, total) {
+  return total === 0 ? 0 : count / total * 100;
+}
+function calculateChoiceDistribution(responses, questionId) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const response of responses) {
+    const value = response.values[questionId];
+    const selections = new Set(Array.isArray(value) ? value : typeof value === "string" && value !== "" ? [value] : []);
+    for (const selection of selections) counts.set(selection, (counts.get(selection) ?? 0) + 1);
+  }
+  return Object.fromEntries(
+    [...counts].map(([value, count]) => [value, { count, percentage: percentage(count, responses.length) }])
+  );
+}
+function calculateNumericSummary(responses, questionId) {
+  const numbers = responses.map((response) => response.values[questionId]).filter((value) => typeof value === "number" && Number.isFinite(value));
+  const total = numbers.reduce((sum, value) => sum + value, 0);
+  return {
+    total,
+    average: numbers.length === 0 ? null : total / numbers.length,
+    min: numbers.length === 0 ? null : Math.min(...numbers),
+    max: numbers.length === 0 ? null : Math.max(...numbers)
+  };
+}
+function valueIsValid(field, value) {
+  if (value === void 0 || value === "") return false;
+  if (field.type === "text" || field.type === "textarea") {
+    if (typeof value !== "string") return false;
+    const normalized = value.trim();
+    if (normalized.length === 0) return false;
+    if (field.minLength !== void 0 && normalized.length < field.minLength) return false;
+    if (field.maxLength !== void 0 && normalized.length > field.maxLength) return false;
+    return field.pattern === void 0 || new RegExp(field.pattern).test(normalized);
+  }
+  if (field.type === "number" || field.type === "rating") {
+    if (typeof value !== "number" || !Number.isFinite(value)) return false;
+    const min = field.type === "rating" ? field.min ?? 1 : field.min;
+    const max = field.type === "rating" ? field.max ?? 5 : field.max;
+    if (min !== void 0 && value < min || max !== void 0 && value > max) return false;
+    if (field.type === "rating") return Number.isInteger(value);
+    if (field.step === void 0) return true;
+    const quotient = (value - (field.min ?? 0)) / field.step;
+    return Math.abs(quotient - Math.round(quotient)) <= 1e-9;
+  }
+  if (field.type === "checkbox") return typeof value === "boolean";
+  if (!("options" in field)) return false;
+  const allowed = new Set(field.options.map((option) => option.id));
+  if (field.type === "multi-select") {
+    return Array.isArray(value) && value.length > 0 && new Set(value).size === value.length && value.every((item) => allowed.has(item)) && (field.minSelections === void 0 || value.length >= field.minSelections) && (field.maxSelections === void 0 || value.length <= field.maxSelections);
+  }
+  return typeof value === "string" && allowed.has(value);
+}
+function aggregateField(schema, field, submissions) {
+  const values = submissions.map((submission) => {
+    const visibility = calculateFieldVisibility(schema, submission.values);
+    const value = submission.values[field.id];
+    return visibility[field.id] === true && valueIsValid(field, value) ? value : void 0;
+  });
+  const answeredCount = values.filter((value) => value !== void 0).length;
+  const base = { fieldId: field.id, answeredCount, unansweredCount: submissions.length - answeredCount };
+  if (field.type === "text" || field.type === "textarea") return { ...base, kind: field.type };
+  if (field.type === "number" || field.type === "rating") {
+    const numbers = values.filter((value) => typeof value === "number");
+    const total = numbers.reduce((sum, value) => sum + value, 0);
+    return {
+      ...base,
+      kind: field.type,
+      minimum: numbers.length === 0 ? null : Math.min(...numbers),
+      maximum: numbers.length === 0 ? null : Math.max(...numbers),
+      average: numbers.length === 0 ? null : total / numbers.length,
+      total
+    };
+  }
+  if (field.type === "checkbox") {
+    const trueCount = values.filter((value) => value === true).length;
+    const falseCount = values.filter((value) => value === false).length;
+    return {
+      ...base,
+      kind: "checkbox",
+      trueCount,
+      falseCount,
+      truePercentageOfSubmissions: percentage(trueCount, submissions.length),
+      falsePercentageOfSubmissions: percentage(falseCount, submissions.length)
+    };
+  }
+  if (!("options" in field)) throw new TypeError(`Field ${field.id} cannot be aggregated.`);
+  const optionCounts = new Map(field.options.map((option) => [option.id, 0]));
+  for (const value of values) {
+    const selections = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+    for (const selection of selections) optionCounts.set(selection, (optionCounts.get(selection) ?? 0) + 1);
+  }
+  const aggregate = {
+    ...base,
+    kind: field.type,
+    options: field.options.map((option) => {
+      const count = optionCounts.get(option.id) ?? 0;
+      return { id: option.id, count, percentageOfSubmissions: percentage(count, submissions.length) };
+    })
+  };
+  return aggregate;
+}
+function aggregateResponses(schema, submissions) {
+  assertValidFormSchema(schema);
+  for (const submission of submissions) {
+    if (submission.formId !== schema.id || submission.formVersion !== schema.version) {
+      throw new TypeError(`Submission ${submission.id} does not match ${schema.id}@${schema.version}.`);
+    }
+  }
+  return {
+    formId: schema.id,
+    formVersion: schema.version,
+    submissionCount: submissions.length,
+    questions: schema.fields.map((field) => aggregateField(schema, field, submissions))
+  };
+}
+function escapeCsvCell(value) {
+  if (value === null || value === void 0) return "";
+  const stringValue = String(value);
+  return /[",\r\n]/.test(stringValue) ? `"${stringValue.replaceAll('"', '""')}"` : stringValue;
+}
+function serializeValue(value) {
+  if (value === void 0) return "";
+  if (Array.isArray(value)) return JSON.stringify(value);
+  return String(value);
+}
+function exportResponsesToCsv(schema, responses, options = {}) {
+  assertValidFormSchema(schema);
+  for (const response of responses) {
+    if (response.formId !== schema.id || response.formVersion !== schema.version) {
+      throw new TypeError(`Submission ${response.id} does not match ${schema.id}@${schema.version}.`);
+    }
+  }
+  const rows = [
+    ["submissionId", "submittedAt", "locale", ...schema.fields.map((field) => field.id)],
+    ...responses.map((response) => {
+      const visible = selectVisibleAnswers(schema, response.values);
+      return [
+        response.id,
+        response.submittedAt,
+        response.locale,
+        ...schema.fields.map((field) => serializeValue(visible[field.id]))
+      ];
+    })
+  ];
+  const csv = rows.map((row) => row.map((cell) => escapeCsvCell(cell)).join(",")).join("\r\n");
+  return options.withBom ?? true ? `\uFEFF${csv}` : csv;
+}
+
+// src/validation.ts
+var DEFAULT_MESSAGES = {
+  required: "validation.required",
+  invalid_type: "validation.invalidType",
+  min_length: "validation.minLength",
+  max_length: "validation.maxLength",
+  pattern: "validation.pattern",
+  min: "validation.min",
+  max: "validation.max",
+  step: "validation.step",
+  invalid_option: "validation.invalidOption",
+  min_selections: "validation.minSelections",
+  max_selections: "validation.maxSelections",
+  unknown_field: "validation.unknownField"
+};
+function addIssue(issues, field, code, params = {}) {
+  issues.push({
+    fieldId: field.id,
+    code,
+    messageKey: field.messages?.[code] ?? DEFAULT_MESSAGES[code],
+    params
+  });
+}
+function isEmpty2(field, value) {
+  if (value === void 0 || value === "") return true;
+  if (field.type === "checkbox") return value !== true;
+  if (field.type === "multi-select") return Array.isArray(value) && value.length === 0;
+  return false;
+}
+function validateField2(field, value, issues) {
+  if (isEmpty2(field, value)) {
+    if (field.required) addIssue(issues, field, "required");
+    return;
+  }
+  if (field.type === "text" || field.type === "textarea") {
+    if (typeof value !== "string") {
+      addIssue(issues, field, "invalid_type");
+      return;
+    }
+    const normalized = value.trim();
+    if (field.required && normalized.length === 0) {
+      addIssue(issues, field, "required");
+      return;
+    }
+    if (field.minLength !== void 0 && normalized.length < field.minLength) {
+      addIssue(issues, field, "min_length", { min: field.minLength });
+    }
+    if (field.maxLength !== void 0 && normalized.length > field.maxLength) {
+      addIssue(issues, field, "max_length", { max: field.maxLength });
+    }
+    if (field.pattern !== void 0 && !new RegExp(field.pattern).test(normalized)) {
+      addIssue(issues, field, "pattern");
+    }
+    return;
+  }
+  if (field.type === "number" || field.type === "rating") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      addIssue(issues, field, "invalid_type");
+      return;
+    }
+    const min = field.type === "rating" ? field.min ?? 1 : field.min;
+    const max = field.type === "rating" ? field.max ?? 5 : field.max;
+    if (min !== void 0 && value < min) addIssue(issues, field, "min", { min });
+    if (max !== void 0 && value > max) addIssue(issues, field, "max", { max });
+    if (field.type === "rating" && !Number.isInteger(value)) {
+      addIssue(issues, field, "step", { step: 1 });
+    } else if (field.type === "number" && field.step !== void 0) {
+      const origin = field.min ?? 0;
+      const quotient = (value - origin) / field.step;
+      if (Math.abs(quotient - Math.round(quotient)) > 1e-9) {
+        addIssue(issues, field, "step", { step: field.step });
+      }
+    }
+    return;
+  }
+  if (field.type === "checkbox") {
+    if (typeof value !== "boolean") addIssue(issues, field, "invalid_type");
+    return;
+  }
+  if (!("options" in field)) {
+    addIssue(issues, field, "invalid_type");
+    return;
+  }
+  const allowed = new Set(field.options.map((option) => option.id));
+  if (field.type === "multi-select") {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+      addIssue(issues, field, "invalid_type");
+      return;
+    }
+    const unique = new Set(value);
+    if (unique.size !== value.length || value.some((item) => !allowed.has(item))) {
+      addIssue(issues, field, "invalid_option");
+    }
+    if (field.minSelections !== void 0 && value.length < field.minSelections) {
+      addIssue(issues, field, "min_selections", { min: field.minSelections });
+    }
+    if (field.maxSelections !== void 0 && value.length > field.maxSelections) {
+      addIssue(issues, field, "max_selections", { max: field.maxSelections });
+    }
+    return;
+  }
+  if (typeof value !== "string") {
+    addIssue(issues, field, "invalid_type");
+  } else if (!allowed.has(value)) {
+    addIssue(issues, field, "invalid_option");
+  }
+}
+function validateAnswers(schema, values) {
+  const issues = [];
+  const fields = new Map(schema.fields.map((field) => [field.id, field]));
+  for (const key of Object.keys(values)) {
+    if (!fields.has(key)) {
+      issues.push({
+        fieldId: key,
+        code: "unknown_field",
+        messageKey: DEFAULT_MESSAGES.unknown_field,
+        params: {}
+      });
+    }
+  }
+  const visibility = calculateFieldVisibility(schema, values);
+  for (const field of schema.fields) {
+    if (visibility[field.id] === true) validateField2(field, values[field.id], issues);
+  }
+  return issues.length === 0 ? { valid: true, issues: [] } : { valid: false, issues };
+}
+
+// src/submission.ts
+function cloneValues(values) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [key, Array.isArray(value) ? Object.freeze([...value]) : value])
+  );
+}
+function createSubmission(schema, values, options) {
+  assertValidFormSchema(schema);
+  if (options.id.trim().length === 0) throw new TypeError("Submission ID must not be empty.");
+  if (options.locale.trim().length === 0) throw new TypeError("Submission locale must not be empty.");
+  const result = validateAnswers(schema, values);
+  if (!result.valid) {
+    throw new TypeError(
+      `Invalid form answers: ${result.issues.map((item) => `${item.fieldId}:${item.code}`).join(", ")}`
+    );
+  }
+  if (options.submittedAt.trim().length === 0 || !Number.isFinite(Date.parse(options.submittedAt))) {
+    throw new TypeError("submittedAt must be a valid date string.");
+  }
+  const visibleValues = selectVisibleAnswers(schema, values);
+  return Object.freeze({
+    id: options.id,
+    formId: schema.id,
+    formVersion: schema.version,
+    locale: options.locale,
+    values: Object.freeze(cloneValues(visibleValues)),
+    submittedAt: options.submittedAt
+  });
+}
+
+// src/translation.ts
+async function resolveFormTranslation(schema, adapter, targetLocale, sourceLocale) {
+  assertValidFormSchema(schema);
+  const texts = [schema.title];
+  if (schema.description !== void 0) texts.push(schema.description);
+  for (const field of schema.fields) {
+    texts.push(field.title);
+    if (field.description !== void 0) texts.push(field.description);
+    if ("options" in field) texts.push(...field.options.map((option) => option.label));
+  }
+  const translated = await adapter.translateBatch(texts, targetLocale, sourceLocale);
+  if (translated.length !== texts.length) {
+    throw new Error(`Translation adapter returned ${translated.length} texts for ${texts.length} inputs.`);
+  }
+  let index = 0;
+  const next = () => {
+    const value = translated[index];
+    index += 1;
+    if (value === void 0) throw new Error("Translation adapter returned an incomplete result.");
+    return value;
+  };
+  const title = next();
+  const description = schema.description === void 0 ? void 0 : next();
+  const fields = schema.fields.map((field) => {
+    const translatedTitle = next();
+    const translatedDescription = field.description === void 0 ? void 0 : next();
+    const base = {
+      ...field,
+      title: translatedTitle,
+      ...translatedDescription === void 0 ? {} : { description: translatedDescription }
+    };
+    if (!("options" in field)) return base;
+    return { ...base, options: field.options.map((option) => ({ ...option, label: next() })) };
+  });
+  const translatedSchema = {
+    ...schema,
+    title,
+    ...description === void 0 ? {} : { description },
+    fields
+  };
+  assertValidFormSchema(translatedSchema);
+  return translatedSchema;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aggregateResponses,
+  assertValidFormSchema,
+  calculateChoiceDistribution,
+  calculateFieldVisibility,
+  calculateNumericSummary,
+  createSubmission,
+  escapeCsvCell,
+  exportResponsesToCsv,
+  isQuestionVisible,
+  resolveFormTranslation,
+  sanitizeSchema,
+  selectVisibleAnswers,
+  validateAnswers,
+  validateFormSchema,
+  validateSchemaStructure
+});