@formality-ui/core 0.0.0

package/dist/index.js

@@ -0,0 +1,1105 @@
+import jsep from 'jsep';
+
+// src/expression/evaluate.ts
+
+// src/expression/context.ts
+var QUALIFIED_PREFIXES = [
+  "fields",
+  "record",
+  "errors",
+  "defaultValues",
+  "touchedFields",
+  "dirtyFields",
+  "props"
+];
+var KEYWORDS = [
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "typeof",
+  "instanceof",
+  "new",
+  "this",
+  "if",
+  "else",
+  "return"
+];
+var FIELD_STATE_PROPERTIES = /* @__PURE__ */ new Set([
+  "value",
+  "isTouched",
+  "isDirty",
+  "isValidating",
+  "error",
+  "invalid"
+]);
+var FIELD_PROXY_MARKER = /* @__PURE__ */ Symbol.for("formality.fieldProxy");
+var FIELD_PROXY_VALUE = /* @__PURE__ */ Symbol.for("formality.fieldProxyValue");
+function createFieldStateProxy(fieldState) {
+  const proxy = new Proxy(fieldState, {
+    get(target, prop) {
+      if (prop === FIELD_PROXY_MARKER) {
+        return true;
+      }
+      if (prop === FIELD_PROXY_VALUE) {
+        return target.value;
+      }
+      if (prop === Symbol.toPrimitive) {
+        return (_hint) => target.value;
+      }
+      if (typeof prop === "string" && FIELD_STATE_PROPERTIES.has(prop)) {
+        return target[prop];
+      }
+      const value = target.value;
+      if (value !== null && value !== void 0 && typeof value === "object") {
+        return value[prop];
+      }
+      return void 0;
+    }
+  });
+  return proxy;
+}
+function isFieldProxy(value) {
+  return value !== null && typeof value === "object" && value[FIELD_PROXY_MARKER] === true;
+}
+function unwrapFieldProxy(value) {
+  if (isFieldProxy(value)) {
+    return value[FIELD_PROXY_VALUE];
+  }
+  return value;
+}
+function buildFormContext(fields, record, errors, defaultValues, touchedFields, dirtyFields) {
+  const context = {};
+  context.fields = fields;
+  context.record = record ?? {};
+  context.errors = errors ?? {};
+  context.defaultValues = defaultValues ?? {};
+  context.touchedFields = touchedFields ?? {};
+  context.dirtyFields = dirtyFields ?? {};
+  for (const [fieldName, fieldState] of Object.entries(fields)) {
+    if (!(fieldName in context)) {
+      context[fieldName] = createFieldStateProxy(fieldState);
+    }
+  }
+  return context;
+}
+function buildFieldContext(formState, fieldName, additionalProps) {
+  const context = buildFormContext(
+    formState.fields,
+    formState.record,
+    formState.errors,
+    formState.defaultValues,
+    formState.touchedFields,
+    formState.dirtyFields
+  );
+  context.props = {
+    name: fieldName,
+    ...additionalProps
+  };
+  return context;
+}
+function buildEvaluationContext(fieldValues, record, props, fieldStates) {
+  const context = {};
+  const fields = {};
+  for (const [name, value] of Object.entries(fieldValues)) {
+    if (fieldStates && fieldStates[name]) {
+      fields[name] = fieldStates[name];
+    } else {
+      fields[name] = { value };
+    }
+  }
+  context.fields = fields;
+  context.record = record ?? {};
+  context.props = props ?? {};
+  for (const [fieldName] of Object.entries(fieldValues)) {
+    if (!(fieldName in context)) {
+      context[fieldName] = createFieldStateProxy(fields[fieldName]);
+    }
+  }
+  return context;
+}
+
+// src/expression/evaluate.ts
+function getProperty(obj, key) {
+  if (obj === null || obj === void 0) {
+    return void 0;
+  }
+  if (typeof obj === "object") {
+    return obj[key];
+  }
+  return void 0;
+}
+function evaluateNode(node, context) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "Identifier":
+      return context[node.name];
+    case "MemberExpression": {
+      const memberNode = node;
+      const object = evaluateNode(memberNode.object, context);
+      if (memberNode.computed) {
+        const property = evaluateNode(memberNode.property, context);
+        return getProperty(object, String(property));
+      } else {
+        return getProperty(object, memberNode.property.name);
+      }
+    }
+    case "BinaryExpression": {
+      const binaryNode = node;
+      switch (binaryNode.operator) {
+        case "&&": {
+          const left2 = evaluateNode(binaryNode.left, context);
+          const leftValue2 = unwrapFieldProxy(left2);
+          return leftValue2 ? evaluateNode(binaryNode.right, context) : leftValue2;
+        }
+        case "||": {
+          const left2 = evaluateNode(binaryNode.left, context);
+          const leftValue2 = unwrapFieldProxy(left2);
+          return leftValue2 ? leftValue2 : evaluateNode(binaryNode.right, context);
+        }
+        case "??": {
+          const left2 = evaluateNode(binaryNode.left, context);
+          const leftValue2 = unwrapFieldProxy(left2);
+          return leftValue2 !== null && leftValue2 !== void 0 ? leftValue2 : evaluateNode(binaryNode.right, context);
+        }
+      }
+      const left = evaluateNode(binaryNode.left, context);
+      const right = evaluateNode(binaryNode.right, context);
+      const leftValue = unwrapFieldProxy(left);
+      const rightValue = unwrapFieldProxy(right);
+      switch (binaryNode.operator) {
+        case "+":
+          return leftValue + rightValue;
+        case "-":
+          return leftValue - rightValue;
+        case "*":
+          return leftValue * rightValue;
+        case "/":
+          return leftValue / rightValue;
+        case "%":
+          return leftValue % rightValue;
+        case "===":
+          return leftValue === rightValue;
+        case "!==":
+          return leftValue !== rightValue;
+        case "==":
+          return leftValue == rightValue;
+        case "!=":
+          return leftValue != rightValue;
+        case "<":
+          return leftValue < rightValue;
+        case ">":
+          return leftValue > rightValue;
+        case "<=":
+          return leftValue <= rightValue;
+        case ">=":
+          return leftValue >= rightValue;
+        default:
+          throw new Error(`Unknown binary operator: ${binaryNode.operator}`);
+      }
+    }
+    case "LogicalExpression": {
+      const logicalNode = node;
+      const left = evaluateNode(logicalNode.left, context);
+      const leftValue = unwrapFieldProxy(left);
+      switch (logicalNode.operator) {
+        case "&&":
+          return leftValue ? evaluateNode(logicalNode.right, context) : leftValue;
+        case "||":
+          return leftValue ? leftValue : evaluateNode(logicalNode.right, context);
+        case "??":
+          return leftValue !== null && leftValue !== void 0 ? leftValue : evaluateNode(logicalNode.right, context);
+        default:
+          throw new Error(`Unknown logical operator: ${logicalNode.operator}`);
+      }
+    }
+    case "UnaryExpression": {
+      const unaryNode = node;
+      const argument = evaluateNode(unaryNode.argument, context);
+      const argValue = unwrapFieldProxy(argument);
+      switch (unaryNode.operator) {
+        case "!":
+          return !argValue;
+        case "-":
+          return -argValue;
+        case "+":
+          return +argValue;
+        case "typeof":
+          return typeof argValue;
+        default:
+          throw new Error(`Unknown unary operator: ${unaryNode.operator}`);
+      }
+    }
+    case "ConditionalExpression": {
+      const condNode = node;
+      const test = evaluateNode(condNode.test, context);
+      const testValue = unwrapFieldProxy(test);
+      return testValue ? evaluateNode(condNode.consequent, context) : evaluateNode(condNode.alternate, context);
+    }
+    case "ArrayExpression": {
+      const arrayNode = node;
+      return arrayNode.elements.map(
+        (element) => element ? evaluateNode(element, context) : void 0
+      );
+    }
+    case "CallExpression": {
+      throw new Error("Function calls are not allowed in expressions");
+    }
+    case "Compound": {
+      const compoundNode = node;
+      let result;
+      for (const bodyNode of compoundNode.body) {
+        result = evaluateNode(bodyNode, context);
+      }
+      return result;
+    }
+    default:
+      throw new Error(`Unknown node type: ${node.type}`);
+  }
+}
+var astCache = /* @__PURE__ */ new Map();
+function parseExpression(expr) {
+  const cached = astCache.get(expr);
+  if (cached) {
+    return cached;
+  }
+  const ast = jsep(expr);
+  astCache.set(expr, ast);
+  return ast;
+}
+function evaluate(expr, context) {
+  try {
+    const ast = parseExpression(expr);
+    const result = evaluateNode(ast, context);
+    const unwrapped = unwrapFieldProxy(result);
+    return unwrapped;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(`Expression evaluation error for "${expr}":`, error);
+    }
+    return void 0;
+  }
+}
+function evaluateDescriptor(descriptor, context) {
+  if (typeof descriptor === "string") {
+    return evaluate(descriptor, context);
+  }
+  if (typeof descriptor === "function") {
+    return descriptor;
+  }
+  if (Array.isArray(descriptor)) {
+    return descriptor.map((item) => evaluateDescriptor(item, context));
+  }
+  if (descriptor !== null && typeof descriptor === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(descriptor)) {
+      result[key] = evaluateDescriptor(value, context);
+    }
+    return result;
+  }
+  return descriptor;
+}
+function clearExpressionCache() {
+  astCache.clear();
+}
+
+// src/expression/infer.ts
+var IDENTIFIER_REGEX = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
+var KEYWORD_SET = new Set(KEYWORDS);
+var QUALIFIED_PREFIX_SET = new Set(QUALIFIED_PREFIXES);
+function inferFieldsFromExpression(expr) {
+  const fields = [];
+  let match;
+  IDENTIFIER_REGEX.lastIndex = 0;
+  while ((match = IDENTIFIER_REGEX.exec(expr)) !== null) {
+    const identifier = match[1];
+    if (KEYWORD_SET.has(identifier)) {
+      continue;
+    }
+    const beforeMatch = expr.slice(0, match.index);
+    const lastNonWhitespace = beforeMatch.trimEnd().slice(-1);
+    if (lastNonWhitespace === ".") {
+      continue;
+    }
+    const afterMatch = expr.slice(match.index + identifier.length);
+    if (afterMatch.startsWith(".") && QUALIFIED_PREFIX_SET.has(identifier)) {
+      continue;
+    }
+    fields.push(identifier);
+  }
+  return [...new Set(fields)];
+}
+function inferFieldsFromDescriptor(descriptor) {
+  if (typeof descriptor === "string") {
+    return inferFieldsFromExpression(descriptor);
+  }
+  if (typeof descriptor === "function") {
+    return [];
+  }
+  if (Array.isArray(descriptor)) {
+    const allFields = [];
+    for (const item of descriptor) {
+      allFields.push(...inferFieldsFromDescriptor(item));
+    }
+    return [...new Set(allFields)];
+  }
+  if (descriptor !== null && typeof descriptor === "object") {
+    const allFields = [];
+    for (const value of Object.values(descriptor)) {
+      allFields.push(...inferFieldsFromDescriptor(value));
+    }
+    return [...new Set(allFields)];
+  }
+  return [];
+}
+
+// src/conditions/evaluate.ts
+function evaluateConditionMatch(condition, context, fieldValues) {
+  let triggerValue;
+  if (condition.when !== void 0) {
+    triggerValue = fieldValues[condition.when];
+  } else if (condition.selectWhen !== void 0) {
+    if (typeof condition.selectWhen === "string") {
+      triggerValue = evaluate(condition.selectWhen, context);
+    } else if (typeof condition.selectWhen === "function") {
+      return false;
+    } else {
+      triggerValue = evaluateDescriptor(condition.selectWhen, context);
+    }
+  } else {
+    return false;
+  }
+  if (condition.is !== void 0) {
+    return triggerValue === condition.is;
+  }
+  if (condition.truthy !== void 0) {
+    const isTruthy = Boolean(triggerValue);
+    return condition.truthy ? isTruthy : !isTruthy;
+  }
+  return Boolean(triggerValue);
+}
+function evaluateConditions(input) {
+  const { conditions, fieldValues, fieldStates, record, props } = input;
+  const context = buildEvaluationContext(fieldValues, record, props, fieldStates);
+  let disabled;
+  let visible;
+  let setValue;
+  let hasDisabledCondition = false;
+  let hasVisibleCondition = false;
+  let hasSetCondition = false;
+  for (const condition of conditions) {
+    const isMatched = evaluateConditionMatch(condition, context, fieldValues);
+    if (!isMatched) {
+      continue;
+    }
+    if (condition.disabled !== void 0) {
+      hasDisabledCondition = true;
+      disabled = (disabled ?? false) || condition.disabled;
+    }
+    if (condition.visible !== void 0) {
+      hasVisibleCondition = true;
+      visible = visible === void 0 ? condition.visible : visible && condition.visible;
+    }
+    if (condition.set !== void 0) {
+      hasSetCondition = true;
+      setValue = condition.set;
+    } else if (condition.selectSet !== void 0) {
+      hasSetCondition = true;
+      if (typeof condition.selectSet === "string") {
+        setValue = unwrapFieldProxy(evaluate(condition.selectSet, context));
+      } else if (typeof condition.selectSet === "function") {
+        setValue = condition.selectSet;
+      } else {
+        setValue = unwrapFieldProxy(evaluateDescriptor(condition.selectSet, context));
+      }
+    }
+  }
+  return {
+    disabled: hasDisabledCondition ? disabled : void 0,
+    visible: hasVisibleCondition ? visible : void 0,
+    setValue: hasSetCondition ? setValue : void 0,
+    hasDisabledCondition,
+    hasVisibleCondition,
+    hasSetCondition
+  };
+}
+function conditionMatches(condition, fieldValues, record, props) {
+  const context = buildEvaluationContext(fieldValues, record, props);
+  return evaluateConditionMatch(condition, context, fieldValues);
+}
+function mergeConditionResults(results) {
+  let disabled;
+  let visible;
+  let setValue;
+  let hasDisabledCondition = false;
+  let hasVisibleCondition = false;
+  let hasSetCondition = false;
+  for (const result of results) {
+    if (result.hasDisabledCondition) {
+      hasDisabledCondition = true;
+      disabled = (disabled ?? false) || (result.disabled ?? false);
+    }
+    if (result.hasVisibleCondition) {
+      hasVisibleCondition = true;
+      visible = visible === void 0 ? result.visible : visible && (result.visible ?? true);
+    }
+    if (result.hasSetCondition) {
+      hasSetCondition = true;
+      setValue = result.setValue;
+    }
+  }
+  return {
+    disabled: hasDisabledCondition ? disabled : void 0,
+    visible: hasVisibleCondition ? visible : void 0,
+    setValue: hasSetCondition ? setValue : void 0,
+    hasDisabledCondition,
+    hasVisibleCondition,
+    hasSetCondition
+  };
+}
+function inferFieldsFromConditions(conditions) {
+  const fields = [];
+  for (const condition of conditions) {
+    if (condition.when !== void 0) {
+      fields.push(condition.when);
+    }
+    if (condition.selectWhen !== void 0) {
+      fields.push(...inferFieldsFromDescriptor(condition.selectWhen));
+    }
+    if (condition.selectSet !== void 0) {
+      fields.push(...inferFieldsFromDescriptor(condition.selectSet));
+    }
+    if (condition.subscribesTo !== void 0) {
+      fields.push(...condition.subscribesTo);
+    }
+  }
+  return [...new Set(fields)];
+}
+
+// src/validation/validate.ts
+function runSingleValidator(validator, value, formValues) {
+  try {
+    return validator(value, formValues);
+  } catch (error) {
+    return {
+      type: "validation_error",
+      message: error instanceof Error ? error.message : "Validation error"
+    };
+  }
+}
+function resolveNamedValidator(name, validators) {
+  const validator = validators[name];
+  if (typeof validator === "function") {
+    return validator;
+  }
+  return void 0;
+}
+async function runValidator(spec, value, formValues, namedValidators) {
+  if (Array.isArray(spec)) {
+    for (const item of spec) {
+      const result = await runValidator(item, value, formValues, namedValidators);
+      if (!isValid(result)) {
+        return result;
+      }
+    }
+    return true;
+  }
+  if (typeof spec === "string") {
+    if (!namedValidators) {
+      console.warn(`Named validator "${spec}" requested but no validators provided`);
+      return true;
+    }
+    const validator = resolveNamedValidator(spec, namedValidators);
+    if (!validator) {
+      console.warn(`Validator "${spec}" not found in validators config`);
+      return true;
+    }
+    const result = runSingleValidator(validator, value, formValues);
+    return Promise.resolve(result);
+  }
+  if (typeof spec === "function") {
+    const result = runSingleValidator(spec, value, formValues);
+    return Promise.resolve(result);
+  }
+  return true;
+}
+function runValidatorSync(spec, value, formValues, namedValidators) {
+  if (Array.isArray(spec)) {
+    for (const item of spec) {
+      const result = runValidatorSync(item, value, formValues, namedValidators);
+      if (!isValid(result)) {
+        return result;
+      }
+    }
+    return true;
+  }
+  if (typeof spec === "string") {
+    if (!namedValidators) {
+      return true;
+    }
+    const validator = resolveNamedValidator(spec, namedValidators);
+    if (!validator) {
+      return true;
+    }
+    const result = validator(value, formValues);
+    return result;
+  }
+  if (typeof spec === "function") {
+    const result = spec(value, formValues);
+    return result;
+  }
+  return true;
+}
+function isValid(result) {
+  if (result === true || result === void 0) {
+    return true;
+  }
+  return false;
+}
+function composeValidators(validators, namedValidators) {
+  return async (value, formValues) => {
+    for (const spec of validators) {
+      const result = await runValidator(spec, value, formValues, namedValidators);
+      if (!isValid(result)) {
+        return result;
+      }
+    }
+    return true;
+  };
+}
+function required() {
+  return (value) => {
+    if (value === void 0 || value === null || value === "") {
+      return { type: "required", message: "This field is required" };
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      return { type: "required", message: "This field is required" };
+    }
+    return true;
+  };
+}
+function minLength(length) {
+  return (value) => {
+    if (typeof value !== "string") {
+      return true;
+    }
+    if (value.length < length) {
+      return {
+        type: "minLength",
+        message: `Must be at least ${length} characters`
+      };
+    }
+    return true;
+  };
+}
+function maxLength(length) {
+  return (value) => {
+    if (typeof value !== "string") {
+      return true;
+    }
+    if (value.length > length) {
+      return {
+        type: "maxLength",
+        message: `Must be at most ${length} characters`
+      };
+    }
+    return true;
+  };
+}
+function pattern(pattern2, message) {
+  return (value) => {
+    if (typeof value !== "string") {
+      return true;
+    }
+    if (!pattern2.test(value)) {
+      return {
+        type: "pattern",
+        message: message ?? "Invalid format"
+      };
+    }
+    return true;
+  };
+}
+
+// src/validation/messages.ts
+function resolveErrorMessage(result, errorMessages) {
+  if (result === true || result === void 0) {
+    return void 0;
+  }
+  if (typeof result === "string") {
+    return result;
+  }
+  if (result === false) {
+    return errorMessages?.["invalid"] ?? "Invalid value";
+  }
+  if (typeof result === "object" && result !== null) {
+    if (result.message) {
+      return result.message;
+    }
+    if (result.type && errorMessages?.[result.type]) {
+      return errorMessages[result.type];
+    }
+    if (result.type) {
+      return formatTypeAsMessage(result.type);
+    }
+    return "Invalid value";
+  }
+  return "Invalid value";
+}
+function formatTypeAsMessage(type) {
+  const words = type.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/_/g, " ").toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function createErrorMessages(overrides) {
+  const defaults = {
+    required: "This field is required",
+    invalid: "Invalid value",
+    minLength: "Too short",
+    maxLength: "Too long",
+    pattern: "Invalid format",
+    min: "Value is too small",
+    max: "Value is too large",
+    email: "Invalid email address",
+    url: "Invalid URL",
+    number: "Must be a number",
+    integer: "Must be a whole number",
+    positive: "Must be positive",
+    negative: "Must be negative",
+    date: "Invalid date",
+    phone: "Invalid phone number",
+    unique: "Must be unique",
+    match: "Fields do not match",
+    validate: "Validation failed"
+  };
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function getErrorType(result) {
+  if (result === true || result === void 0) {
+    return void 0;
+  }
+  if (result === false) {
+    return "invalid";
+  }
+  if (typeof result === "string") {
+    return "validate";
+  }
+  if (typeof result === "object" && result !== null) {
+    return result.type || "validate";
+  }
+  return "validate";
+}
+function createValidationError(type, message, errorMessages) {
+  const resolvedMessage = message ?? errorMessages?.[type] ?? formatTypeAsMessage(type);
+  return {
+    type,
+    message: resolvedMessage
+  };
+}
+
+// src/transform/pipeline.ts
+function parse(value, parserSpec, namedParsers) {
+  if (parserSpec === void 0) {
+    return value;
+  }
+  if (typeof parserSpec === "string") {
+    const parser = namedParsers?.[parserSpec];
+    if (!parser) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`Parser "${parserSpec}" not found in parsers config`);
+      }
+      return value;
+    }
+    try {
+      return parser(value);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`Parser "${parserSpec}" threw error:`, error);
+      }
+      return value;
+    }
+  }
+  if (typeof parserSpec === "function") {
+    try {
+      return parserSpec(value);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("Inline parser threw error:", error);
+      }
+      return value;
+    }
+  }
+  return value;
+}
+function format(value, formatterSpec, namedFormatters) {
+  if (formatterSpec === void 0) {
+    return value;
+  }
+  if (typeof formatterSpec === "string") {
+    const formatter = namedFormatters?.[formatterSpec];
+    if (!formatter) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`Formatter "${formatterSpec}" not found in formatters config`);
+      }
+      return value;
+    }
+    try {
+      return formatter(value);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn(`Formatter "${formatterSpec}" threw error:`, error);
+      }
+      return value;
+    }
+  }
+  if (typeof formatterSpec === "function") {
+    try {
+      return formatterSpec(value);
+    } catch (error) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("Inline formatter threw error:", error);
+      }
+      return value;
+    }
+  }
+  return value;
+}
+function extractValueField(value, valueField) {
+  if (!valueField) {
+    return value;
+  }
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  return value[valueField];
+}
+function transformFieldName(fieldName, getSubmitField) {
+  if (!getSubmitField) {
+    return fieldName;
+  }
+  return getSubmitField(fieldName);
+}
+function createFloatParser(fallback = 0) {
+  return (value) => {
+    const parsed = parseFloat(String(value));
+    return isNaN(parsed) ? fallback : parsed;
+  };
+}
+function createFloatFormatter(precision = 2) {
+  return (value) => {
+    if (typeof value !== "number" || isNaN(value)) {
+      return "";
+    }
+    return value.toFixed(precision);
+  };
+}
+function createIntParser(fallback = 0) {
+  return (value) => {
+    const parsed = parseInt(String(value), 10);
+    return isNaN(parsed) ? fallback : parsed;
+  };
+}
+function createTrimParser() {
+  return (value) => {
+    if (typeof value !== "string") {
+      return value;
+    }
+    return value.trim();
+  };
+}
+function createDefaultParsers() {
+  return {
+    float: createFloatParser(),
+    int: createIntParser(),
+    integer: createIntParser(),
+    trim: createTrimParser(),
+    string: (value) => String(value ?? "")
+  };
+}
+function createDefaultFormatters() {
+  return {
+    float: createFloatFormatter(2),
+    float2: createFloatFormatter(2),
+    float3: createFloatFormatter(3),
+    float4: createFloatFormatter(4),
+    percent: createFloatFormatter(2),
+    percent3: createFloatFormatter(3),
+    integer: (value) => {
+      if (typeof value !== "number" || isNaN(value)) {
+        return "";
+      }
+      return Math.round(value).toString();
+    },
+    string: (value) => String(value ?? "")
+  };
+}
+
+// src/config/merge.ts
+function deepMerge(base, override) {
+  if (!override) {
+    return base;
+  }
+  const result = { ...base };
+  for (const key in override) {
+    const baseValue = base[key];
+    const overrideValue = override[key];
+    if (overrideValue === void 0) {
+      continue;
+    }
+    if (typeof baseValue === "object" && baseValue !== null && typeof overrideValue === "object" && overrideValue !== null && !Array.isArray(baseValue) && !Array.isArray(overrideValue)) {
+      result[key] = deepMerge(
+        baseValue,
+        overrideValue
+      );
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+function mergeInputConfigs(providerInputs, formInputs) {
+  if (!formInputs) {
+    return providerInputs;
+  }
+  if (typeof formInputs === "function") {
+    const transformed = formInputs(providerInputs);
+    return mergeInputConfigs(providerInputs, transformed);
+  }
+  const result = { ...providerInputs };
+  for (const [type, overrides] of Object.entries(formInputs)) {
+    if (result[type]) {
+      result[type] = deepMerge(result[type], overrides);
+    } else {
+      result[type] = overrides;
+    }
+  }
+  return result;
+}
+function resolveInputConfig(type, inputs, defaultType = "textField") {
+  return inputs[type] ?? inputs[defaultType];
+}
+function resolveFieldType(componentType, fieldConfig, defaultType = "textField") {
+  return componentType ?? fieldConfig?.type ?? defaultType;
+}
+function mergeStaticProps(...layers) {
+  const result = {};
+  for (const layer of layers) {
+    if (layer) {
+      Object.assign(result, layer);
+    }
+  }
+  return result;
+}
+function mergeFieldProps(options) {
+  const {
+    providerDefaultFieldProps,
+    providerSelectDefaultFieldProps,
+    formDefaultFieldProps,
+    formSelectDefaultFieldProps,
+    inputProps,
+    fieldConfigProps,
+    selectProps,
+    componentProps,
+    coreProps
+  } = options;
+  return mergeStaticProps(
+    providerDefaultFieldProps,
+    providerSelectDefaultFieldProps,
+    formDefaultFieldProps,
+    formSelectDefaultFieldProps,
+    inputProps,
+    fieldConfigProps,
+    selectProps,
+    componentProps,
+    coreProps
+    // Core props always win (name, value, onChange, etc.)
+  );
+}
+function createConfigContext(providerConfig, formConfig) {
+  const mergedInputs = mergeInputConfigs(
+    providerConfig.inputs,
+    formConfig?.inputs
+  );
+  return {
+    inputs: mergedInputs,
+    formatters: providerConfig.formatters ?? {},
+    parsers: providerConfig.parsers ?? {},
+    validators: providerConfig.validators ?? {},
+    errorMessages: providerConfig.errorMessages ?? {},
+    defaultFieldProps: mergeStaticProps(
+      providerConfig.defaultFieldProps,
+      formConfig?.defaultFieldProps
+    ),
+    selectDefaultFieldProps: formConfig?.selectDefaultFieldProps ?? providerConfig.selectDefaultFieldProps
+  };
+}
+
+// src/config/defaults.ts
+function resolveInitialValue(fieldName, fieldConfig, inputConfig, record, defaultValues) {
+  if (defaultValues && fieldName in defaultValues) {
+    return defaultValues[fieldName];
+  }
+  const recordKey = fieldConfig?.recordKey ?? fieldName;
+  if (record && recordKey in record) {
+    return record[recordKey];
+  }
+  if (inputConfig?.defaultValue !== void 0) {
+    return inputConfig.defaultValue;
+  }
+  return void 0;
+}
+function resolveAllInitialValues(fieldConfigs, inputs, record, defaultValues) {
+  const result = {};
+  for (const [fieldName, fieldConfig] of Object.entries(fieldConfigs)) {
+    const type = fieldConfig.type ?? "textField";
+    const inputConfig = inputs[type];
+    const value = resolveInitialValue(
+      fieldName,
+      fieldConfig,
+      inputConfig,
+      record,
+      defaultValues
+    );
+    if (value !== void 0) {
+      result[fieldName] = value;
+    }
+  }
+  if (defaultValues) {
+    for (const [fieldName, value] of Object.entries(defaultValues)) {
+      if (!(fieldName in result)) {
+        result[fieldName] = value;
+      }
+    }
+  }
+  return result;
+}
+function isEmptyValue(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (value === "") {
+    return true;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  return false;
+}
+function getInputDefaultValue(inputConfig, typeName) {
+  if (inputConfig?.defaultValue !== void 0) {
+    return inputConfig.defaultValue;
+  }
+  if (typeName) {
+    switch (typeName) {
+      case "switch":
+      case "checkbox":
+        return false;
+      case "number":
+      case "decimal":
+      case "integer":
+        return 0;
+      case "select":
+      case "autocomplete":
+        return null;
+      case "multiSelect":
+      case "checkboxGroup":
+        return [];
+      case "textField":
+      case "text":
+      case "textarea":
+      case "email":
+      case "password":
+      default:
+        return "";
+    }
+  }
+  return "";
+}
+function mergeRecordWithDefaults(record, defaults) {
+  const result = {};
+  if (defaults) {
+    Object.assign(result, defaults);
+  }
+  if (record) {
+    for (const [key, value] of Object.entries(record)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/labels/resolve.ts
+function humanizeLabel(fieldName) {
+  if (!fieldName) {
+    return "";
+  }
+  if (/[^a-zA-Z0-9]/.test(fieldName)) {
+    return fieldName.charAt(0).toUpperCase() + fieldName.slice(1);
+  }
+  const words = fieldName.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(" ");
+  return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function resolveLabel(fieldName, fieldConfig, evaluatedSelectProps, componentProps) {
+  if (componentProps?.label !== void 0) {
+    return String(componentProps.label);
+  }
+  if (fieldConfig?.props?.label !== void 0) {
+    return String(fieldConfig.props.label);
+  }
+  if (evaluatedSelectProps?.label !== void 0) {
+    return String(evaluatedSelectProps.label);
+  }
+  if (fieldConfig?.label !== void 0) {
+    return fieldConfig.label;
+  }
+  if (fieldConfig?.title !== void 0) {
+    return fieldConfig.title;
+  }
+  return humanizeLabel(fieldName);
+}
+function resolveFormTitle(formTitle, evaluatedSelectTitle) {
+  if (evaluatedSelectTitle !== void 0 && evaluatedSelectTitle !== null) {
+    return String(evaluatedSelectTitle);
+  }
+  return formTitle;
+}
+function isAutoGeneratedLabel(fieldName, label) {
+  return humanizeLabel(fieldName) === label;
+}
+function createLabelWithUnit(baseLabel, unit) {
+  return `${baseLabel} (${unit})`;
+}
+function parseLabelWithUnit(label) {
+  const match = label.match(/^(.+)\s*\(([^)]+)\)$/);
+  if (match) {
+    return {
+      base: match[1].trim(),
+      unit: match[2]
+    };
+  }
+  return { base: label };
+}
+function sortFieldsByOrder(fieldNames, fieldConfigs) {
+  return [...fieldNames].sort((a, b) => {
+    const orderA = fieldConfigs[a]?.order ?? Infinity;
+    const orderB = fieldConfigs[b]?.order ?? Infinity;
+    return orderA - orderB;
+  });
+}
+function getUnusedFields(allFields, declaredFields) {
+  return allFields.filter((name) => !declaredFields.has(name));
+}
+function getOrderedUnusedFields(allFields, declaredFields, fieldConfigs) {
+  const unused = getUnusedFields(allFields, declaredFields);
+  return sortFieldsByOrder(unused, fieldConfigs);
+}
+
+export { FIELD_PROXY_MARKER, FIELD_PROXY_VALUE, KEYWORDS, QUALIFIED_PREFIXES, buildEvaluationContext, buildFieldContext, buildFormContext, clearExpressionCache, composeValidators, conditionMatches, createConfigContext, createDefaultFormatters, createDefaultParsers, createErrorMessages, createFieldStateProxy, createFloatFormatter, createFloatParser, createIntParser, createLabelWithUnit, createTrimParser, createValidationError, deepMerge, evaluate, evaluateConditions, evaluateDescriptor, extractValueField, format, formatTypeAsMessage, getErrorType, getInputDefaultValue, getOrderedUnusedFields, getUnusedFields, humanizeLabel, inferFieldsFromConditions, inferFieldsFromDescriptor, inferFieldsFromExpression, isAutoGeneratedLabel, isEmptyValue, isFieldProxy, isValid, maxLength, mergeConditionResults, mergeFieldProps, mergeInputConfigs, mergeRecordWithDefaults, mergeStaticProps, minLength, parse, parseLabelWithUnit, pattern, required, resolveAllInitialValues, resolveErrorMessage, resolveFieldType, resolveFormTitle, resolveInitialValue, resolveInputConfig, resolveLabel, runValidator, runValidatorSync, sortFieldsByOrder, transformFieldName, unwrapFieldProxy };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map