@evanschleret/formforgeclient 1.2.4 → 2.0.0

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

@@ -1,6 +1,15 @@
 import type { FormForgeJsonObject, FormForgeJsonValue } from './json.js';
 import type { FormForgeCategory } from './category.js';
-export type FormForgeFieldType = 'text' | 'textarea' | 'email' | 'number' | 'select' | 'select_menu' | 'radio' | 'checkbox' | 'checkbox_group' | 'switch' | 'date' | 'time' | 'datetime' | 'date_range' | 'datetime_range' | 'file';
+export type FormForgeFieldType = 'text' | 'textarea' | 'email' | 'number' | 'select' | 'select_menu' | 'radio' | 'checkbox' | 'consent' | 'checkbox_group' | 'switch' | 'temporal' | 'date' | 'time' | 'file' | 'address';
+export type FormForgeTemporalMode = 'date' | 'time';
+export type FormForgeTemporalHourCycle = 12 | 24;
+export type FormForgeAddressFieldKey = 'line1' | 'line2' | 'city' | 'state' | 'zip' | 'country';
+export interface FormForgeAddressFieldSchema {
+    key: FormForgeAddressFieldKey;
+    label: string;
+    visible: boolean;
+    required: boolean;
+}
 export type FormForgeOptionValue = string | number | boolean | null;
 export interface FormForgeFieldOptionObject {
     label?: string;
@@ -35,19 +44,43 @@ export interface FormForgeFieldSchemaBase<TType extends FormForgeFieldType> {
     disabled?: boolean;
     readonly?: boolean;
     options?: FormForgeFieldOption[];
+    display?: 'list' | 'menu';
+    temporal_mode?: FormForgeTemporalMode;
+    hour_cycle?: FormForgeTemporalHourCycle;
+    consent_label?: string;
+    address_fields?: FormForgeAddressFieldSchema[];
 }
 export type FormForgeTextLikeFieldSchema = FormForgeFieldSchemaBase<'text' | 'textarea' | 'email'>;
 export type FormForgeNumberFieldSchema = FormForgeFieldSchemaBase<'number'>;
 export type FormForgeSelectLikeFieldSchema = FormForgeFieldSchemaBase<'select' | 'select_menu' | 'radio' | 'checkbox_group'>;
-export type FormForgeBooleanFieldSchema = FormForgeFieldSchemaBase<'checkbox' | 'switch'>;
-export type FormForgeDateLikeFieldSchema = FormForgeFieldSchemaBase<'date' | 'time' | 'datetime' | 'date_range' | 'datetime_range'>;
+export type FormForgeBooleanFieldSchema = FormForgeFieldSchemaBase<'checkbox' | 'consent' | 'switch'>;
+export type FormForgeDateLikeFieldSchema = FormForgeFieldSchemaBase<'date' | 'time'>;
+export type FormForgeTemporalFieldSchema = FormForgeFieldSchemaBase<'temporal'>;
+export type FormForgeAddressFieldSchemaValue = FormForgeFieldSchemaBase<'address'>;
 export interface FormForgeFileFieldSchema extends FormForgeFieldSchemaBase<'file'> {
     accept?: string[];
     max_size?: number | null;
     max_files?: number | null;
     storage?: FormForgeFieldStorage | null;
 }
-export type FormForgeFieldSchema = FormForgeTextLikeFieldSchema | FormForgeNumberFieldSchema | FormForgeSelectLikeFieldSchema | FormForgeBooleanFieldSchema | FormForgeDateLikeFieldSchema | FormForgeFileFieldSchema;
+export type FormForgeFieldSchema = FormForgeTextLikeFieldSchema | FormForgeNumberFieldSchema | FormForgeSelectLikeFieldSchema | FormForgeBooleanFieldSchema | FormForgeTemporalFieldSchema | FormForgeDateLikeFieldSchema | FormForgeAddressFieldSchemaValue | FormForgeFileFieldSchema;
+export type FormForgeFieldValidationMatch = 'all' | 'any';
+export type FormForgeFieldValidationOperator = 'min' | 'max' | 'after' | 'before' | 'between' | 'not_between' | 'regex' | 'eq' | 'neq' | 'contains' | 'not_contains';
+export interface FormForgeTemporalValidationRangeValue {
+    start: string | null;
+    end: string | null;
+}
+export interface FormForgeFieldValidationRule {
+    validation_key: string;
+    target?: string | null;
+    operator: FormForgeFieldValidationOperator;
+    value: string | number | null | FormForgeTemporalValidationRangeValue;
+    unit?: 'characters' | null;
+}
+export interface FormForgeFieldValidationConfig {
+    match: FormForgeFieldValidationMatch;
+    rules: FormForgeFieldValidationRule[];
+}
 export interface FormForgePageSchema {
     page_key: string;
     title: string;
@@ -55,6 +88,35 @@ export interface FormForgePageSchema {
     meta: FormForgeJsonObject;
     fields: FormForgeFieldSchema[];
 }
+export type FormForgePageLogicMatch = 'all' | 'any';
+export type FormForgePageLogicOperator = 'eq' | 'neq' | 'contains' | 'not_contains' | 'starts_with' | 'not_starts_with' | 'ends_with' | 'not_ends_with' | 'is_submitted' | 'is_not_submitted' | 'accepted' | 'ignored';
+export type FormForgePageLogicThenAction = 'require' | 'goto_block';
+export type FormForgePageLogicFallbackAction = 'next' | 'goto_block';
+export interface FormForgePageLogicClause {
+    field_key: string;
+    operator: FormForgePageLogicOperator;
+    value: FormForgeJsonValue;
+}
+export interface FormForgePageLogicThen {
+    action: FormForgePageLogicThenAction;
+    field_key?: string | null;
+    block_index?: number | null;
+}
+export interface FormForgePageLogicFallback {
+    action: FormForgePageLogicFallbackAction;
+    block_index?: number | null;
+}
+export interface FormForgePageLogicRule {
+    rule_key: string;
+    match: FormForgePageLogicMatch;
+    when: FormForgePageLogicClause[];
+    then: FormForgePageLogicThen[];
+    fallback: FormForgePageLogicFallback;
+}
+export interface FormForgePageLogic {
+    version?: number;
+    rules: FormForgePageLogicRule[];
+}
 export type FormForgeConditionTargetType = 'page' | 'field';
 export type FormForgeConditionAction = 'show' | 'hide' | 'skip' | 'require' | 'disable';
 export type FormForgeConditionMatch = 'all' | 'any';
@@ -79,10 +141,16 @@ export interface FormForgeDraftSettings {
 export interface FormForgeFormSchema {
     key: string;
     version: string;
+    schema_version: number;
     title: string;
+    publish_at?: string | null;
+    pause_at?: string | null;
+    response_limit?: number | null;
+    submission_code_required?: boolean;
     category?: string | null;
     category_item?: FormForgeCategory | null;
     is_published: boolean;
+    public_url?: string | null;
     fields: FormForgeFieldSchema[];
     pages: FormForgePageSchema[];
     conditions: FormForgeCondition[];

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

@@ -0,0 +1,7 @@
+import type { FormForgeAddressFieldSchema, FormForgeFieldType, FormForgeTemporalMode } from '../types/index.js';
+export type FormForgeLocale = 'en' | 'fr';
+export declare function createDefaultAddressFields(locale?: string): FormForgeAddressFieldSchema[];
+export declare function resolveDefaultFieldLabel(type: FormForgeFieldType, locale?: string, temporalMode?: FormForgeTemporalMode): string;
+export declare function resolveDefaultAnswerPlaceholder(locale?: string): string;
+export declare function resolveDefaultConsentLabel(locale?: string): string;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/runtime/utils/defaults.js

@@ -0,0 +1,86 @@
+const DEFAULT_ADDRESS_FIELDS = {
+  en: [
+    { key: "line1", label: "Address line 1", visible: true, required: true },
+    { key: "line2", label: "Address line 2", visible: false, required: false },
+    { key: "city", label: "City", visible: true, required: true },
+    { key: "state", label: "State", visible: false, required: false },
+    { key: "zip", label: "Zip", visible: true, required: true },
+    { key: "country", label: "Country", visible: true, required: true }
+  ],
+  fr: [
+    { key: "line1", label: "Ligne d'adresse 1", visible: true, required: true },
+    { key: "line2", label: "Ligne d'adresse 2", visible: false, required: false },
+    { key: "city", label: "Ville", visible: true, required: true },
+    { key: "state", label: "\xC9tat", visible: false, required: false },
+    { key: "zip", label: "Code postal", visible: true, required: true },
+    { key: "country", label: "Pays", visible: true, required: true }
+  ]
+};
+const DEFAULT_FIELD_LABELS = {
+  en: {
+    text: "Free text",
+    textarea: "Long text",
+    email: "Email",
+    number: "Number",
+    select: "Dropdown",
+    select_menu: "Dropdown menu",
+    radio: "Single choice",
+    checkbox: "Checkbox",
+    consent: "Consent",
+    checkbox_group: "Multiple choice",
+    switch: "Switch",
+    temporal: "Date",
+    date: "Date",
+    time: "Time",
+    file: "File upload",
+    address: "Address"
+  },
+  fr: {
+    text: "Texte libre",
+    textarea: "R\xE9ponse longue",
+    email: "E-mail",
+    number: "Nombre",
+    select: "S\xE9lection",
+    select_menu: "Menu d\xE9roulant",
+    radio: "Choix unique",
+    checkbox: "Case \xE0 cocher",
+    consent: "Consentement",
+    checkbox_group: "Choix multiples",
+    switch: "Interrupteur",
+    temporal: "Date",
+    date: "Date",
+    time: "Heure",
+    file: "T\xE9l\xE9versement de fichier",
+    address: "Adresse"
+  }
+};
+const DEFAULT_ANSWER_PLACEHOLDER = {
+  en: "Enter your answer here ...",
+  fr: "Entrez votre r\xE9ponse ici ..."
+};
+const DEFAULT_CONSENT_LABEL = {
+  en: "I agree",
+  fr: "J'accepte"
+};
+function normalizeLocale(locale) {
+  if (typeof locale !== "string" || locale.trim() === "") {
+    return "en";
+  }
+  return locale.toLowerCase().startsWith("fr") ? "fr" : "en";
+}
+export function createDefaultAddressFields(locale) {
+  return DEFAULT_ADDRESS_FIELDS[normalizeLocale(locale)].map((field) => ({ ...field }));
+}
+export function resolveDefaultFieldLabel(type, locale, temporalMode) {
+  const resolvedLocale = normalizeLocale(locale);
+  if (type === "temporal") {
+    return temporalMode === "time" ? DEFAULT_FIELD_LABELS[resolvedLocale].time : DEFAULT_FIELD_LABELS[resolvedLocale].date;
+  }
+  return DEFAULT_FIELD_LABELS[resolvedLocale][type] ?? DEFAULT_FIELD_LABELS[resolvedLocale].text;
+}
+export function resolveDefaultAnswerPlaceholder(locale) {
+  return DEFAULT_ANSWER_PLACEHOLDER[normalizeLocale(locale)];
+}
+export function resolveDefaultConsentLabel(locale) {
+  return DEFAULT_CONSENT_LABEL[normalizeLocale(locale)];
+}

package/dist/runtime/utils/page-logic.d.ts

@@ -0,0 +1,24 @@
+import type { FormForgeFieldSchema, FormForgeFieldType, FormForgePageLogic, FormForgePageLogicClause, FormForgePageLogicFallback, FormForgePageLogicOperator, FormForgePageLogicRule, FormForgePageLogicThen, FormForgePageSchema } from '../types/index.js';
+export declare function isTextLikeFieldType(type: FormForgeFieldType): boolean;
+export declare function isChoiceFieldType(type: FormForgeFieldType): boolean;
+export declare function isConsentFieldType(type: FormForgeFieldType): boolean;
+export declare function pageLogicOperatorsForFieldType(type: FormForgeFieldType): FormForgePageLogicOperator[];
+export declare function pageLogicOperatorRequiresValue(type: FormForgeFieldType, operator: FormForgePageLogicOperator): boolean;
+export declare function createPageLogicRule(): FormForgePageLogicRule;
+export declare function createPageLogic(): FormForgePageLogic;
+export declare function normalizePageLogic(value: unknown): FormForgePageLogic;
+export declare function normalizePageLogicRule(value: Partial<FormForgePageLogicRule>): FormForgePageLogicRule;
+export declare function normalizePageLogicClause(value: Partial<FormForgePageLogicClause>): FormForgePageLogicClause;
+export declare function normalizePageLogicThen(value: Partial<FormForgePageLogicThen> | undefined): FormForgePageLogicThen;
+export declare function normalizePageLogicFallback(value: Partial<FormForgePageLogicFallback> | undefined): FormForgePageLogicFallback;
+export declare function createPageLogicThen(): FormForgePageLogicThen;
+export declare function ensurePageLogic(page: FormForgePageSchema): FormForgePageLogic;
+export declare function getPageLogic(page: FormForgePageSchema): FormForgePageLogic;
+export declare function getPageLogicRuleQuestions(page: FormForgePageSchema): FormForgeFieldSchema[];
+export declare function getFuturePageQuestions(pages: FormForgePageSchema[], pageIndex: number): FormForgeFieldSchema[];
+export declare function findFieldByKey(page: FormForgePageSchema, fieldKey: string): FormForgeFieldSchema | undefined;
+export declare function evaluatePageLogicClause(clause: FormForgePageLogicClause, field: FormForgeFieldSchema | undefined, actualValue: unknown): boolean;
+export declare function evaluatePageLogicRule(rule: FormForgePageLogicRule, page: FormForgePageSchema, getActualValue: (field: FormForgeFieldSchema) => unknown): boolean;
+export declare function resolvePageLogicJumpTarget(rule: FormForgePageLogicRule, currentPageIndex: number, pageCount: number): number | null;
+export declare function normalizeJumpIndex(value: unknown, currentPageIndex: number, pageCount: number): number | null;
+//# sourceMappingURL=page-logic.d.ts.map

package/dist/runtime/utils/page-logic.js

@@ -0,0 +1,351 @@
+const TEXT_FIELD_TYPES = ["text", "textarea", "email"];
+const CHOICE_FIELD_TYPES = ["select", "select_menu", "radio", "checkbox_group"];
+const TEMPORAL_FIELD_TYPES = ["temporal", "date", "time"];
+const TEXT_OPERATORS = [
+  "eq",
+  "neq",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "not_starts_with",
+  "ends_with",
+  "not_ends_with",
+  "is_submitted"
+];
+const ADDRESS_OPERATORS = [
+  "is_submitted",
+  "is_not_submitted"
+];
+const CONSENT_OPERATORS = ["accepted", "ignored"];
+const CHOICE_OPERATORS = ["eq", "neq"];
+export function isTextLikeFieldType(type) {
+  return TEXT_FIELD_TYPES.includes(type);
+}
+export function isChoiceFieldType(type) {
+  return CHOICE_FIELD_TYPES.includes(type);
+}
+export function isConsentFieldType(type) {
+  return type === "consent";
+}
+export function pageLogicOperatorsForFieldType(type) {
+  if (type === "address") {
+    return ADDRESS_OPERATORS;
+  }
+  if (TEMPORAL_FIELD_TYPES.includes(type)) {
+    return ADDRESS_OPERATORS;
+  }
+  if (isConsentFieldType(type)) {
+    return CONSENT_OPERATORS;
+  }
+  if (isChoiceFieldType(type)) {
+    return CHOICE_OPERATORS;
+  }
+  return TEXT_OPERATORS;
+}
+export function pageLogicOperatorRequiresValue(type, operator) {
+  if (type === "address") {
+    return false;
+  }
+  if (TEMPORAL_FIELD_TYPES.includes(type)) {
+    return false;
+  }
+  if (isConsentFieldType(type)) {
+    return false;
+  }
+  if (isChoiceFieldType(type)) {
+    return operator === "eq" || operator === "neq";
+  }
+  return operator !== "is_submitted";
+}
+export function createPageLogicRule() {
+  return {
+    rule_key: `lr_${Math.random().toString(36).slice(2, 8)}`,
+    match: "all",
+    when: [
+      {
+        field_key: "",
+        operator: "eq",
+        value: null
+      }
+    ],
+    then: [createPageLogicThen()],
+    fallback: {
+      action: "next",
+      block_index: null
+    }
+  };
+}
+export function createPageLogic() {
+  return {
+    version: 1,
+    rules: []
+  };
+}
+export function normalizePageLogic(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return createPageLogic();
+  }
+  const candidate = value;
+  const rules = Array.isArray(candidate.rules) ? candidate.rules : [];
+  return {
+    version: typeof candidate.version === "number" && Number.isFinite(candidate.version) ? candidate.version : 1,
+    rules: rules.filter((rule) => rule !== null && typeof rule === "object" && !Array.isArray(rule)).map((rule) => normalizePageLogicRule(rule))
+  };
+}
+export function normalizePageLogicRule(value) {
+  const when = Array.isArray(value.when) ? value.when : [];
+  const nextWhen = when.filter((clause) => clause !== null && typeof clause === "object" && !Array.isArray(clause)).map((clause) => normalizePageLogicClause(clause));
+  const thenSource = value.then;
+  const thenList = Array.isArray(thenSource) ? thenSource : [thenSource];
+  return {
+    rule_key: typeof value.rule_key === "string" && value.rule_key !== "" ? value.rule_key : `lr_${Math.random().toString(36).slice(2, 8)}`,
+    match: value.match === "any" ? "any" : "all",
+    when: nextWhen.length > 0 ? nextWhen : [createPageLogicRule().when[0]],
+    then: (() => {
+      const normalizedThen = thenList.filter((entry) => entry !== null && entry !== "").map((entry) => normalizePageLogicThen(entry));
+      const dedupedThen = [];
+      const seenRequireFieldKeys = /* @__PURE__ */ new Set();
+      for (const thenAction of normalizedThen) {
+        if (thenAction.action === "require" && typeof thenAction.field_key === "string" && thenAction.field_key !== "") {
+          if (seenRequireFieldKeys.has(thenAction.field_key)) {
+            continue;
+          }
+          seenRequireFieldKeys.add(thenAction.field_key);
+        }
+        dedupedThen.push(thenAction);
+      }
+      return dedupedThen.length > 0 ? dedupedThen : [createPageLogicThen()];
+    })(),
+    fallback: normalizePageLogicFallback(value.fallback)
+  };
+}
+export function normalizePageLogicClause(value) {
+  return {
+    field_key: typeof value.field_key === "string" ? value.field_key : "",
+    operator: isPageLogicOperator(value.operator) ? value.operator : "eq",
+    value: value.value ?? null
+  };
+}
+export function normalizePageLogicThen(value) {
+  return {
+    action: value?.action === "goto_block" ? "goto_block" : "require",
+    field_key: typeof value?.field_key === "string" ? value.field_key : null,
+    block_index: normalizeNullableBlockIndex(value?.block_index)
+  };
+}
+export function normalizePageLogicFallback(value) {
+  return {
+    action: value?.action === "goto_block" ? "goto_block" : "next",
+    block_index: normalizeNullableBlockIndex(value?.block_index)
+  };
+}
+export function createPageLogicThen() {
+  return {
+    action: "require",
+    field_key: null,
+    block_index: null
+  };
+}
+export function ensurePageLogic(page) {
+  const meta = ensurePageMeta(page);
+  if (!isPageLogic(meta.logic)) {
+    meta.logic = createPageLogic();
+  } else {
+    meta.logic = normalizePageLogic(meta.logic);
+  }
+  return meta.logic;
+}
+export function getPageLogic(page) {
+  const meta = ensurePageMeta(page);
+  return normalizePageLogic(meta.logic);
+}
+export function getPageLogicRuleQuestions(page) {
+  return Array.isArray(page.fields) ? page.fields : [];
+}
+export function getFuturePageQuestions(pages, pageIndex) {
+  const fields = [];
+  for (let index = pageIndex + 1; index < pages.length; index += 1) {
+    const page = pages[index];
+    if (!page || !Array.isArray(page.fields)) {
+      continue;
+    }
+    fields.push(...page.fields);
+  }
+  return fields;
+}
+export function findFieldByKey(page, fieldKey) {
+  return Array.isArray(page.fields) ? page.fields.find((field) => field.field_key === fieldKey) : void 0;
+}
+export function evaluatePageLogicClause(clause, field, actualValue) {
+  if (field === void 0) {
+    return false;
+  }
+  if (clause.operator === "accepted") {
+    return actualValue === true;
+  }
+  if (clause.operator === "ignored") {
+    return actualValue !== true;
+  }
+  if (clause.operator === "is_submitted") {
+    return !isEmptyValue(actualValue);
+  }
+  if (clause.operator === "is_not_submitted") {
+    return isEmptyValue(actualValue);
+  }
+  if (clause.operator === "eq") {
+    return areValuesEqual(actualValue, clause.value);
+  }
+  if (clause.operator === "neq") {
+    return !areValuesEqual(actualValue, clause.value);
+  }
+  if (typeof actualValue !== "string") {
+    return false;
+  }
+  const actual = actualValue;
+  const expected = typeof clause.value === "string" ? clause.value : String(clause.value ?? "");
+  if (clause.operator === "contains") {
+    return actual.includes(expected);
+  }
+  if (clause.operator === "not_contains") {
+    return !actual.includes(expected);
+  }
+  if (clause.operator === "starts_with") {
+    return actual.startsWith(expected);
+  }
+  if (clause.operator === "not_starts_with") {
+    return !actual.startsWith(expected);
+  }
+  if (clause.operator === "ends_with") {
+    return actual.endsWith(expected);
+  }
+  if (clause.operator === "not_ends_with") {
+    return !actual.endsWith(expected);
+  }
+  return false;
+}
+export function evaluatePageLogicRule(rule, page, getActualValue) {
+  if (!Array.isArray(rule.when) || rule.when.length === 0) {
+    return false;
+  }
+  const results = rule.when.map((clause) => {
+    const field = findFieldByKey(page, clause.field_key);
+    const actualValue = field === void 0 ? void 0 : getActualValue(field);
+    return evaluatePageLogicClause(clause, field, actualValue);
+  });
+  if (rule.match === "any") {
+    return results.includes(true);
+  }
+  return !results.includes(false);
+}
+export function resolvePageLogicJumpTarget(rule, currentPageIndex, pageCount) {
+  const fallbackIndex = normalizeJumpIndex(rule.fallback.block_index, currentPageIndex, pageCount);
+  for (const thenAction of rule.then) {
+    const thenIndex = normalizeJumpIndex(thenAction.block_index, currentPageIndex, pageCount);
+    if (thenAction.action === "goto_block" && thenIndex !== null) {
+      return thenIndex;
+    }
+  }
+  if (rule.fallback.action === "goto_block" && fallbackIndex !== null) {
+    return fallbackIndex;
+  }
+  return null;
+}
+export function normalizeJumpIndex(value, currentPageIndex, pageCount) {
+  const numeric = normalizeNullableBlockIndex(value);
+  if (numeric === null) {
+    return null;
+  }
+  const zeroBased = numeric - 1;
+  if (zeroBased < 0 || zeroBased >= pageCount) {
+    return null;
+  }
+  if (zeroBased <= currentPageIndex) {
+    return null;
+  }
+  return zeroBased;
+}
+function normalizeNullableBlockIndex(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return null;
+  }
+  const normalized = Math.trunc(value);
+  return normalized > 0 ? normalized : null;
+}
+function ensurePageMeta(page) {
+  if (typeof page.meta !== "object" || page.meta === null || Array.isArray(page.meta)) {
+    page.meta = {};
+  }
+  return page.meta;
+}
+function isPageLogic(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Array.isArray(value.rules);
+}
+function isPageLogicOperator(value) {
+  return typeof value === "string" && [
+    "eq",
+    "neq",
+    "contains",
+    "not_contains",
+    "starts_with",
+    "not_starts_with",
+    "ends_with",
+    "not_ends_with",
+    "is_submitted",
+    "is_not_submitted",
+    "accepted",
+    "ignored"
+  ].includes(value);
+}
+function areValuesEqual(left, right) {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    return left.every((entry, index) => areValuesEqual(entry, right[index]));
+  }
+  if (isPlainObject(left) && isPlainObject(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+      return false;
+    }
+    for (const key of leftKeys) {
+      if (!areValuesEqual(left[key], right[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  if (typeof File !== "undefined" && value instanceof File) {
+    return false;
+  }
+  return true;
+}
+function isEmptyValue(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim() === "";
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (isPlainObject(value)) {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return true;
+    }
+    return entries.every(([, entry]) => isEmptyValue(entry));
+  }
+  return false;
+}

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

@@ -0,0 +1,3 @@
+export declare function sanitizeFormForgeRichText(value: string | null | undefined): string;
+export declare function sanitizeFormForgeInlineRichText(value: string | null | undefined): string;
+//# sourceMappingURL=rich-text.d.ts.map

package/dist/runtime/utils/rich-text.js

@@ -0,0 +1,72 @@
+const ALLOWED_TAGS = /* @__PURE__ */ new Set(["a", "b", "br", "em", "i", "li", "ol", "p", "strong", "u", "ul"]);
+function sanitizeHref(value) {
+  const href = value.trim();
+  if (href === "") {
+    return null;
+  }
+  if (/^(https?:|mailto:|tel:|\/|#)/i.test(href)) {
+    return href;
+  }
+  return null;
+}
+function sanitizeAttributes(tagName, rawAttributes) {
+  if (tagName !== "a") {
+    return "";
+  }
+  const hrefMatch = rawAttributes.match(/\bhref\s*=\s*("([^"]*)"|'([^']*)'|([^\s"'>`]+))/i);
+  if (hrefMatch === null) {
+    return "";
+  }
+  const hrefValue = hrefMatch[2] ?? hrefMatch[3] ?? hrefMatch[4] ?? "";
+  const safeHref = sanitizeHref(hrefValue);
+  if (safeHref === null) {
+    return "";
+  }
+  return ` href="${safeHref.replaceAll('"', """)}"`;
+}
+export function sanitizeFormForgeRichText(value) {
+  if (typeof value !== "string" || value === "") {
+    return "";
+  }
+  const tokens = value.match(/<\/?[^>]+>|[^<]+/g);
+  if (tokens === null) {
+    return "";
+  }
+  let output = "";
+  const openTags = [];
+  for (const token of tokens) {
+    if (!token.startsWith("<")) {
+      output += token;
+      continue;
+    }
+    const closing = token.startsWith("</");
+    const match = token.match(/^<\/?\s*([a-zA-Z0-9-]+)([^>]*)\/?\s*>$/);
+    if (match === null) {
+      continue;
+    }
+    const tagName = match[1]?.toLowerCase() ?? "";
+    if (!ALLOWED_TAGS.has(tagName)) {
+      continue;
+    }
+    if (tagName === "br") {
+      output += "<br>";
+      continue;
+    }
+    if (closing) {
+      const openTag = openTags.at(-1);
+      if (openTag !== tagName) {
+        continue;
+      }
+      openTags.pop();
+      output += `</${tagName}>`;
+      continue;
+    }
+    const attributes = sanitizeAttributes(tagName, match[2] ?? "");
+    output += `<${tagName}${attributes}>`;
+    openTags.push(tagName);
+  }
+  return output;
+}
+export function sanitizeFormForgeInlineRichText(value) {
+  return sanitizeFormForgeRichText(value).replaceAll(/<\/?p[^>]*>/gi, "").trim();
+}

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

@@ -1,3 +1,3 @@
 import type { FormForgeFormSchema, FormForgeJsonObject } from '../types/index.js';
-export declare function normalizeFormForgeSchema(payload: FormForgeJsonObject): FormForgeFormSchema;
+export declare function normalizeFormForgeSchema(payload: FormForgeJsonObject, locale?: string): FormForgeFormSchema;
 //# sourceMappingURL=schema.d.ts.map