@formos/kernel 0.1.0

package/dist/index.js

@@ -0,0 +1,763 @@
+// src/state.ts
+var FormState = class {
+  /** Field values */
+  values = /* @__PURE__ */ new Map();
+  /** Field errors */
+  errors = /* @__PURE__ */ new Map();
+  /** Touched fields (user has interacted) */
+  touched = /* @__PURE__ */ new Set();
+  /** Dirty fields (value has changed from default) */
+  dirty = /* @__PURE__ */ new Set();
+  /** Current step index (for multi-step forms) */
+  currentStepIndex = 0;
+  /** Initial values (for reset) */
+  initialValues = /* @__PURE__ */ new Map();
+  constructor(defaultValues) {
+    if (defaultValues) {
+      this.values = new Map(defaultValues);
+      this.initialValues = new Map(defaultValues);
+    }
+  }
+  // ========================================================================
+  // VALUES
+  // ========================================================================
+  getValue(fieldName) {
+    return this.values.get(fieldName);
+  }
+  setValue(fieldName, value) {
+    this.values.set(fieldName, value);
+    const initialValue = this.initialValues.get(fieldName);
+    if (value !== initialValue) {
+      this.dirty.add(fieldName);
+    } else {
+      this.dirty.delete(fieldName);
+    }
+  }
+  getAllValues() {
+    return this.values;
+  }
+  // ========================================================================
+  // ERRORS
+  // ========================================================================
+  getError(fieldName) {
+    return this.errors.get(fieldName);
+  }
+  setError(fieldName, error) {
+    if (error) {
+      this.errors.set(fieldName, error);
+    } else {
+      this.errors.delete(fieldName);
+    }
+  }
+  getAllErrors() {
+    const errorObj = {};
+    this.errors.forEach((error, fieldName) => {
+      errorObj[fieldName] = error;
+    });
+    return errorObj;
+  }
+  clearError(fieldName) {
+    this.errors.delete(fieldName);
+  }
+  clearAllErrors() {
+    this.errors.clear();
+  }
+  hasErrors() {
+    return Array.from(this.errors.values()).some(Boolean);
+  }
+  // ========================================================================
+  // TOUCHED
+  // ========================================================================
+  markTouched(fieldName) {
+    this.touched.add(fieldName);
+  }
+  isTouched(fieldName) {
+    return this.touched.has(fieldName);
+  }
+  // ========================================================================
+  // DIRTY
+  // ========================================================================
+  isDirty(fieldName) {
+    return this.dirty.has(fieldName);
+  }
+  isFormDirty() {
+    return this.dirty.size > 0;
+  }
+  // ========================================================================
+  // STEP
+  // ========================================================================
+  getCurrentStepIndex() {
+    return this.currentStepIndex;
+  }
+  setCurrentStepIndex(index) {
+    this.currentStepIndex = index;
+  }
+  // ========================================================================
+  // RESET
+  // ========================================================================
+  reset() {
+    this.values = new Map(this.initialValues);
+    this.errors.clear();
+    this.touched.clear();
+    this.dirty.clear();
+    this.currentStepIndex = 0;
+  }
+};
+
+// src/steps.ts
+var StepController = class {
+  schema;
+  state;
+  constructor(schema, state) {
+    this.schema = schema;
+    this.state = state;
+  }
+  // ========================================================================
+  // STEP QUERIES
+  // ========================================================================
+  /**
+   * Check if this is a multi-step form
+   */
+  isMultiStep() {
+    return this.schema?.isMultiStep ?? false;
+  }
+  /**
+   * Get total number of steps
+   */
+  getTotalSteps() {
+    return this.schema?.steps?.length ?? 1;
+  }
+  /**
+   * Get current step index (0-based)
+   */
+  getCurrentStepIndex() {
+    if (!this.isMultiStep()) {
+      return 0;
+    }
+    return this.state.getCurrentStepIndex();
+  }
+  /**
+   * Get current step ID
+   */
+  getCurrentStepId() {
+    if (!this.isMultiStep()) {
+      return void 0;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    const step = this.schema?.steps?.[currentIndex];
+    return step?.id;
+  }
+  /**
+   * Get current step schema
+   */
+  getCurrentStep() {
+    if (!this.isMultiStep()) {
+      return void 0;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    return this.schema?.steps?.[currentIndex];
+  }
+  // ========================================================================
+  // NAVIGATION
+  // ========================================================================
+  /**
+   * Check if can navigate to next step
+   */
+  canGoNext() {
+    if (!this.isMultiStep()) {
+      return false;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    const totalSteps = this.getTotalSteps();
+    return currentIndex < totalSteps - 1;
+  }
+  /**
+   * Check if can navigate to previous step
+   */
+  canGoPrev() {
+    if (!this.isMultiStep()) {
+      return false;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    const currentStep = this.getCurrentStep();
+    if (currentStep?.allowBack === false) {
+      return false;
+    }
+    return currentIndex > 0;
+  }
+  /**
+   * Navigate to next step
+   * Returns true if navigation succeeded
+   */
+  nextStep() {
+    if (!this.canGoNext()) {
+      return false;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    this.state.setCurrentStepIndex(currentIndex + 1);
+    return true;
+  }
+  /**
+   * Navigate to previous step
+   * Returns true if navigation succeeded
+   */
+  prevStep() {
+    if (!this.canGoPrev()) {
+      return false;
+    }
+    const currentIndex = this.getCurrentStepIndex();
+    this.state.setCurrentStepIndex(currentIndex - 1);
+    return true;
+  }
+  /**
+   * Jump to specific step index
+   */
+  goToStep(index) {
+    if (!this.isMultiStep()) {
+      return false;
+    }
+    const totalSteps = this.getTotalSteps();
+    if (index < 0 || index >= totalSteps) {
+      return false;
+    }
+    this.state.setCurrentStepIndex(index);
+    return true;
+  }
+  // ========================================================================
+  // VALIDATION
+  // ========================================================================
+  /**
+   * Check if current step allows proceeding without validation
+   */
+  allowNextWithoutValidation() {
+    const currentStep = this.getCurrentStep();
+    return currentStep?.allowNextWithoutValidation ?? false;
+  }
+  /**
+   * Check if current step is required
+   */
+  isCurrentStepRequired() {
+    const currentStep = this.getCurrentStep();
+    return currentStep?.required ?? true;
+  }
+  /**
+   * Get fields for current step
+   */
+  getCurrentStepFields() {
+    if (!this.isMultiStep()) {
+      return this.schema?.fieldNames ?? [];
+    }
+    const currentStep = this.getCurrentStep();
+    return currentStep?.fields ?? [];
+  }
+};
+
+// src/engine/init.ts
+function initializeFormState(schema) {
+  const defaultValues = /* @__PURE__ */ new Map();
+  schema?.fields?.forEach((field) => {
+    if (field?.defaultValue !== void 0) {
+      defaultValues.set(field?.name, field.defaultValue);
+    }
+  });
+  return new FormState(defaultValues);
+}
+function initializeStepController(schema, state) {
+  if (!schema?.steps || schema?.steps?.length === 0) {
+    return void 0;
+  }
+  return new StepController(schema, state);
+}
+function isDirty(state) {
+  const values = state.getAllValues();
+  for (const fieldName of values.keys()) {
+    if (state.isDirty(fieldName)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/validation.ts
+import { shouldValidateOnTrigger } from "@formos/schema";
+async function validateField(field, value, trigger, validators, context) {
+  const validations = field?.validations ?? [];
+  const relevantValidations = validations.filter(
+    (validation) => {
+      if (trigger === "manual") {
+        return true;
+      }
+      return shouldValidateOnTrigger(validation, trigger);
+    }
+  );
+  for (const validation of relevantValidations) {
+    const error = await executeValidation(
+      validation,
+      value,
+      validators,
+      context
+    );
+    if (error) {
+      return {
+        fieldName: field?.name,
+        isValid: false,
+        error
+      };
+    }
+  }
+  return {
+    fieldName: field?.name,
+    isValid: true
+  };
+}
+async function executeValidation(validation, value, validators, context) {
+  const executor = validators?.[validation?.validator];
+  if (!executor) {
+    console.warn(
+      `Validator "${validation?.validator}" not found. Skipping validation for field "${context?.fieldName}".`
+    );
+    return null;
+  }
+  try {
+    const result = await executor(value, validation?.rule, context);
+    if (result && validation?.message) {
+      return validation.message;
+    }
+    return result;
+  } catch (error) {
+    console.error(`Validation error for field "${context?.fieldName}":`, error);
+    return "Validation failed";
+  }
+}
+async function validateFields(fields, values, trigger, validators, getValue2) {
+  const errors = /* @__PURE__ */ new Map();
+  const validationPromises = fields.map((field) => {
+    const value = values.get(field?.name);
+    const context = {
+      fieldName: field?.name,
+      values,
+      getValue: getValue2
+    };
+    return validateField(field, value, trigger, validators, context);
+  });
+  const results = await Promise.all(validationPromises);
+  results.forEach((result) => {
+    if (!result?.isValid && result?.error && result?.fieldName) {
+      errors.set(result.fieldName, result.error);
+    }
+  });
+  return errors;
+}
+
+// src/effects.ts
+async function executeEffects(sourceField, sourceValue, effects, effectExecutors, values, getValue2, setValue2) {
+  if (!effects || effects?.length === 0) {
+    return;
+  }
+  const relevantEffects = effects.filter(
+    (effect) => effect?.sourceField === sourceField
+  );
+  for (const effect of relevantEffects) {
+    await executeEffect(
+      effect,
+      sourceField,
+      sourceValue,
+      effectExecutors,
+      values,
+      getValue2,
+      setValue2
+    );
+  }
+}
+async function executeEffect(effect, sourceField, sourceValue, effectExecutors, values, getValue2, setValue2) {
+  const { type, config, targetField } = effect;
+  if (type === "sync") {
+    await executeSyncEffect(
+      sourceValue,
+      targetField,
+      config,
+      effectExecutors,
+      values,
+      getValue2,
+      setValue2
+    );
+    return;
+  }
+  const executor = effectExecutors?.[type];
+  if (!executor) {
+    console.warn(`Effect executor "${type}" not found. Skipping effect.`);
+    return;
+  }
+  const context = {
+    sourceField,
+    sourceValue,
+    targetField,
+    values,
+    getValue: getValue2,
+    setValue: setValue2
+  };
+  try {
+    await executor(config, context);
+  } catch (error) {
+    console.error(`Effect execution error for field "${sourceField}":`, error);
+  }
+}
+async function executeSyncEffect(sourceValue, targetField, config, effectExecutors, values, getValue2, setValue2) {
+  if (!targetField) {
+    console.warn("Sync effect requires targetField");
+    return;
+  }
+  const syncExecutor = effectExecutors?.["sync"];
+  if (syncExecutor) {
+    const context = {
+      sourceField: "",
+      sourceValue,
+      targetField,
+      values,
+      getValue: getValue2,
+      setValue: setValue2
+    };
+    const transformedValue = await syncExecutor(config, context);
+    setValue2(targetField, transformedValue);
+  } else {
+    setValue2(targetField, sourceValue);
+  }
+}
+
+// src/conditionals.ts
+function evaluateConditional(conditional, getValue2) {
+  if ("logic" in conditional) {
+    return evaluateConditionalGroup(conditional, getValue2);
+  }
+  return evaluateConditionalRule(conditional, getValue2);
+}
+function evaluateConditionalGroup(group, getValue2) {
+  const { logic, rules } = group;
+  if (!rules || rules?.length === 0) {
+    return true;
+  }
+  if (logic === "and") {
+    return rules.every(
+      (rule) => evaluateConditional(rule, getValue2)
+    );
+  } else {
+    return rules.some(
+      (rule) => evaluateConditional(rule, getValue2)
+    );
+  }
+}
+function evaluateConditionalRule(rule, getValue2) {
+  const { field, operator, value } = rule;
+  const fieldValue = getValue2(field);
+  switch (operator) {
+    case "equals":
+      return fieldValue === value;
+    case "notEquals":
+      return fieldValue !== value;
+    case "exists":
+      return fieldValue !== void 0 && fieldValue !== null && fieldValue !== "";
+    case "notExists":
+      return fieldValue === void 0 || fieldValue === null || fieldValue === "";
+    case "includes":
+      if (Array.isArray(fieldValue)) {
+        return fieldValue.includes(value);
+      }
+      if (typeof fieldValue === "string" && typeof value === "string") {
+        return fieldValue.includes(value);
+      }
+      return false;
+    case "notIncludes":
+      if (Array.isArray(fieldValue)) {
+        return !fieldValue.includes(value);
+      }
+      if (typeof fieldValue === "string" && typeof value === "string") {
+        return !fieldValue.includes(value);
+      }
+      return true;
+    case "greaterThan":
+      if (typeof fieldValue === "number" && typeof value === "number") {
+        return fieldValue > value;
+      }
+      return false;
+    case "lessThan":
+      if (typeof fieldValue === "number" && typeof value === "number") {
+        return fieldValue < value;
+      }
+      return false;
+    default:
+      return false;
+  }
+}
+function isFieldVisible(field, getValue2) {
+  if (!field?.visibleWhen) {
+    return true;
+  }
+  return evaluateConditional(field.visibleWhen, getValue2);
+}
+function isFieldRequired(field, getValue2) {
+  if (field?.required === void 0) {
+    return false;
+  }
+  if (typeof field.required === "boolean") {
+    return field.required;
+  }
+  return evaluateConditional(field.required, getValue2);
+}
+
+// src/engine/helpers.ts
+function getVisibleFields(schema, getValue2) {
+  return schema?.fields?.filter((field) => {
+    return isFieldVisible(field, getValue2);
+  }) ?? [];
+}
+function getFieldSchema(schema, fieldName) {
+  return schema?.fieldMap?.get(fieldName);
+}
+
+// src/engine/values.ts
+function getValue(state, fieldName) {
+  return state.getValue(fieldName);
+}
+async function setValue(state, schema, fieldName, value, options, validators, effectExecutors, getValueHelper) {
+  const { trigger = "onChange", silent = false } = options;
+  state.setValue(fieldName, value);
+  if (silent) {
+    return;
+  }
+  state.clearError(fieldName);
+  if (trigger !== "manual") {
+    const field2 = getFieldSchema(schema, fieldName);
+    if (field2) {
+      const context = {
+        fieldName,
+        values: state.getAllValues(),
+        getValue: getValueHelper
+      };
+      const result = await validateField(
+        field2,
+        value,
+        trigger,
+        validators,
+        context
+      );
+      if (!result?.isValid && result?.error) {
+        state.setError(fieldName, result?.error);
+      }
+    }
+  }
+  const field = getFieldSchema(schema, fieldName);
+  const fieldEffects = field?.effects ?? [];
+  const globalEffects = schema?.globalEffects ?? [];
+  const allEffects = [...fieldEffects, ...globalEffects];
+  await executeEffects(
+    fieldName,
+    value,
+    allEffects,
+    effectExecutors,
+    state.getAllValues(),
+    getValueHelper,
+    (field2, val) => state.setValue(field2, val)
+  );
+}
+
+// src/engine/validation-ops.ts
+function isValid(state) {
+  return !state.hasErrors();
+}
+function getError(state, fieldName) {
+  return state.getError(fieldName);
+}
+function getErrors(state) {
+  return state.getAllErrors();
+}
+async function validate(state, schema, validators, getValue2, fieldName, trigger = "manual") {
+  if (fieldName) {
+    const field = getFieldSchema(schema, fieldName);
+    if (!field) {
+      return true;
+    }
+    const value = state.getValue(fieldName);
+    const context = {
+      fieldName,
+      values: state.getAllValues(),
+      getValue: getValue2
+    };
+    const result = await validateField(
+      field,
+      value,
+      trigger,
+      validators,
+      context
+    );
+    if (result?.isValid) {
+      state.clearError(fieldName);
+      return true;
+    } else {
+      state.setError(fieldName, result?.error);
+      return false;
+    }
+  } else {
+    const visibleFields = getVisibleFields(schema, getValue2);
+    state.clearAllErrors();
+    const errors = await validateFields(
+      visibleFields,
+      state.getAllValues(),
+      trigger,
+      validators,
+      getValue2
+    );
+    errors.forEach((error, field) => {
+      if (error) {
+        state.setError(field, error);
+      }
+    });
+    return !Array.from(errors.values()).some(Boolean);
+  }
+}
+
+// src/engine/lifecycle.ts
+async function submit(state, schema, validators, getValue2, onSubmit) {
+  const visibleFields = getVisibleFields(schema, getValue2);
+  state.clearAllErrors();
+  const errors = await validateFields(
+    visibleFields,
+    state.getAllValues(),
+    "onSubmit",
+    validators,
+    getValue2
+  );
+  errors.forEach((error, field) => {
+    if (error) {
+      state.setError(field, error);
+    }
+  });
+  const hasErrors = Array.from(errors.values()).some(Boolean);
+  if (!hasErrors && onSubmit) {
+    const values = {};
+    state.getAllValues().forEach((value, key) => {
+      values[key] = value;
+    });
+    await onSubmit(values);
+    return true;
+  }
+  return !hasErrors;
+}
+function reset(state, stepController, schema) {
+  state.reset();
+  schema?.fields?.forEach((field) => {
+    if (field?.defaultValue !== void 0) {
+      state.setValue(field?.name, field.defaultValue);
+    }
+  });
+  if (stepController) {
+    stepController.goToStep(0);
+  }
+}
+
+// src/engine/factory.ts
+function createFormEngine(schema, options = {}) {
+  const { validators = {}, effectExecutors = {}, onSubmit } = options;
+  const state = initializeFormState(schema);
+  const stepController = initializeStepController(
+    schema,
+    state
+  );
+  const getValueHelper = (fieldName) => getValue(state, fieldName);
+  const engine = {
+    // State accessors
+    getValue: (fieldName) => getValue(state, fieldName),
+    getError: (fieldName) => getError(state, fieldName),
+    getErrors: () => getErrors(state),
+    isValid: () => isValid(state),
+    isDirty: (fieldName) => fieldName ? state.isDirty(fieldName) : isDirty(state),
+    isTouched: (fieldName) => state.isTouched(fieldName),
+    // State mutators
+    setValue: async (fieldName, value, opts) => {
+      await setValue(
+        state,
+        schema,
+        fieldName,
+        value,
+        opts ?? {},
+        validators,
+        effectExecutors,
+        getValueHelper
+      );
+    },
+    setError: (fieldName, error) => {
+      state.setError(fieldName, error);
+    },
+    clearError: (fieldName) => {
+      state.clearError(fieldName);
+    },
+    markTouched: (fieldName) => {
+      state.markTouched(fieldName);
+    },
+    // Validation
+    validate: async (fieldName, trigger = "manual") => {
+      return validate(
+        state,
+        schema,
+        validators,
+        getValueHelper,
+        fieldName,
+        trigger
+      );
+    },
+    // Lifecycle
+    submit: async () => {
+      return submit(state, schema, validators, getValueHelper, onSubmit);
+    },
+    reset: () => {
+      reset(state, stepController, schema);
+    }
+  };
+  if (stepController) {
+    engine.getCurrentStep = () => stepController.getCurrentStepIndex();
+    engine.getTotalSteps = () => stepController.getTotalSteps();
+    engine.nextStep = async () => {
+      if (!stepController.canGoNext()) {
+        return false;
+      }
+      const isCurrentStepValid = await validate(
+        state,
+        schema,
+        validators,
+        getValueHelper
+      );
+      if (!isCurrentStepValid) {
+        return false;
+      }
+      return stepController.nextStep();
+    };
+    engine.prevStep = () => {
+      stepController.prevStep();
+    };
+    engine.goToStep = async (stepIndex) => {
+      if (stepIndex === stepController.getCurrentStepIndex()) {
+        return true;
+      }
+      const isCurrentStepValid = await validate(
+        state,
+        schema,
+        validators,
+        getValueHelper
+      );
+      if (!isCurrentStepValid) {
+        return false;
+      }
+      return stepController.goToStep(stepIndex);
+    };
+    engine.canGoToStep = (stepIndex) => {
+      return stepIndex >= 0 && stepIndex < stepController.getTotalSteps();
+    };
+  }
+  return engine;
+}
+export {
+  createFormEngine,
+  evaluateConditional,
+  isFieldRequired,
+  isFieldVisible
+};
+//# sourceMappingURL=index.js.map