@vtaits/form-schema/dist/chunk-3DE3JEEE.js

Serialization and parsing form values by schema

// src/core/parse.ts
var defaultParser = ({
  values,
  name
}) => {
  if (typeof values[name] !== "undefined") {
    return {
      [name]: values[name]
    };
  }
  return {
    [name]: null
  };
};
async function parse({
  values,
  names,
  getFieldSchema,
  getFieldType,
  parents
}) {
  if (!values) {
    return {};
  }
  const preparsedValues = await Promise.all(
    names.map(async (name) => {
      const fieldSchema = getFieldSchema(name);
      const fieldType = getFieldType(fieldSchema);
      const dependencies = fieldSchema.getDependencies?.({
        values,
        phase: "parse",
        getFieldSchema,
        getFieldType,
        parents
      });
      const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
        fieldSchema,
        getFieldSchema,
        getFieldType,
        values,
        phase: "parse",
        parents,
        dependencies
      }) : getFieldSchema;
      const params = {
        value: values[name],
        values,
        name,
        fieldSchema,
        getFieldSchema: computedGetFieldSchema,
        getFieldType,
        parents,
        dependencies
      };
      const parserSingle = fieldSchema.parserSingle || fieldType.parserSingle;
      if (parserSingle) {
        const singleResult = await parserSingle(params);
        return {
          [name]: singleResult
        };
      }
      const parser = fieldSchema.parser || fieldType.parser || defaultParser;
      return parser(params);
    })
  );
  const res = {};
  for (const parsedValue of preparsedValues) {
    Object.assign(res, parsedValue);
  }
  return res;
}

// src/core/parseSingle.ts
async function parseSingle({
  values,
  name,
  getFieldSchema,
  getFieldType,
  parents
}) {
  if (!values) {
    return null;
  }
  const fieldSchema = getFieldSchema(name);
  const fieldType = getFieldType(fieldSchema);
  const dependencies = fieldSchema.getDependencies?.({
    values,
    phase: "parse",
    getFieldSchema,
    getFieldType,
    parents
  });
  const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
    fieldSchema,
    getFieldSchema,
    getFieldType,
    values,
    phase: "parse",
    parents,
    dependencies
  }) : getFieldSchema;
  const params = {
    value: values[name],
    values,
    name,
    fieldSchema,
    getFieldSchema: computedGetFieldSchema,
    getFieldType,
    parents,
    dependencies
  };
  const parserSingle = fieldSchema.parserSingle || fieldType.parserSingle;
  if (parserSingle) {
    return parserSingle(params);
  }
  const parser = fieldSchema.parser || fieldType.parser || defaultParser;
  const parserResult = await parser(params);
  return parserResult[name];
}

// src/core/serialize.ts
var defaultSerializer = ({
  values,
  name
}) => {
  if (typeof values[name] !== "undefined") {
    return {
      [name]: values[name]
    };
  }
  return {};
};
async function serialize({
  values,
  names,
  getFieldSchema,
  getFieldType,
  parents
}) {
  const preserializedValues = await Promise.all(
    names.map(async (name) => {
      const fieldSchema = getFieldSchema(name);
      const fieldType = getFieldType(fieldSchema);
      const dependencies = fieldSchema.getDependencies?.({
        values,
        phase: "serialize",
        getFieldSchema,
        getFieldType,
        parents
      });
      const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
        fieldSchema,
        getFieldSchema,
        getFieldType,
        values,
        phase: "serialize",
        parents,
        dependencies
      }) : getFieldSchema;
      const params = {
        value: values[name],
        values,
        name,
        fieldSchema,
        getFieldSchema: computedGetFieldSchema,
        getFieldType,
        parents,
        dependencies
      };
      const serializerSingle = fieldSchema.serializerSingle || fieldType.serializerSingle;
      if (serializerSingle) {
        const singleResult = await serializerSingle(params);
        return {
          [name]: singleResult
        };
      }
      const serializer = fieldSchema.serializer || fieldType.serializer || defaultSerializer;
      return serializer(params);
    })
  );
  const res = {};
  for (const serializedValue of preserializedValues) {
    Object.assign(res, serializedValue);
  }
  return res;
}

// src/core/serializeSingle.ts
async function serializeSingle({
  values,
  name,
  getFieldSchema,
  getFieldType,
  parents
}) {
  const fieldSchema = getFieldSchema(name);
  const fieldType = getFieldType(fieldSchema);
  const dependencies = fieldSchema.getDependencies?.({
    values,
    phase: "serialize",
    getFieldSchema,
    getFieldType,
    parents
  });
  const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
    fieldSchema,
    getFieldSchema,
    getFieldType,
    values,
    phase: "serialize",
    parents,
    dependencies
  }) : getFieldSchema;
  const params = {
    value: values[name],
    values,
    name,
    fieldSchema,
    getFieldSchema: computedGetFieldSchema,
    getFieldType,
    parents,
    dependencies
  };
  const serializerSingle = fieldSchema.serializerSingle || fieldType.serializerSingle;
  if (serializerSingle) {
    return serializerSingle(params);
  }
  const serializer = fieldSchema.serializer || fieldType.serializer || defaultSerializer;
  const serialized = await serializer(params);
  return serialized[name];
}

// src/core/setFieldErrors.ts
var defaultFieldErrorsSetter = ({ setError, errors, name, parents }) => {
  if (typeof errors[name] !== "undefined") {
    setError(name, parents, errors[name]);
  }
};
async function setFieldErrors({
  setError,
  errors,
  names,
  getFieldSchema,
  getFieldType,
  values,
  rawValues,
  parents
}) {
  await Promise.all(
    names.map(async (name) => {
      const fieldSchema = getFieldSchema(name);
      const fieldType = getFieldType(fieldSchema);
      const dependencies = fieldSchema.getDependencies?.({
        values,
        phase: "serialize",
        getFieldSchema,
        getFieldType,
        parents
      });
      const errorsSetter = fieldSchema.errorsSetter || fieldType.errorsSetter || defaultFieldErrorsSetter;
      const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
        fieldSchema,
        getFieldSchema,
        getFieldType,
        values: rawValues,
        phase: "serialize",
        parents,
        dependencies
      }) : getFieldSchema;
      await errorsSetter({
        setError,
        setCurrentError: (error) => {
          setError(name, parents, error);
        },
        errors,
        name,
        fieldSchema,
        getFieldSchema: computedGetFieldSchema,
        getFieldType,
        value: values[name],
        values,
        rawValue: rawValues[name],
        rawValues,
        parents,
        dependencies
      });
    })
  );
}

// src/core/setValues.ts
var defaultValueSetter = ({
  setValue,
  value,
  name,
  parents
}) => {
  if (typeof value === "undefined") {
    return;
  }
  const prefix = parents.filter((parent) => typeof parent.name !== "undefined").map((parent) => parent.name).join(".");
  setValue(prefix ? `${prefix}.${name}` : `${name}`, value);
};
async function setValues({
  setValue,
  values,
  names,
  getFieldSchema,
  getFieldType,
  parents
}) {
  await Promise.all(
    names.map(async (name) => {
      const fieldSchema = getFieldSchema(name);
      const fieldType = getFieldType(fieldSchema);
      const dependencies = fieldSchema.getDependencies?.({
        values,
        phase: "render",
        getFieldSchema,
        getFieldType,
        parents
      });
      const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
        fieldSchema,
        getFieldSchema,
        getFieldType,
        values,
        phase: "render",
        parents,
        dependencies
      }) : getFieldSchema;
      const params = {
        setValue,
        value: values[name],
        values,
        name,
        fieldSchema,
        getFieldSchema: computedGetFieldSchema,
        getFieldType,
        parents,
        dependencies
      };
      const valueSetter = fieldSchema.valueSetter || fieldType.valueSetter || defaultValueSetter;
      valueSetter(params);
    })
  );
}

// src/core/validateBeforeSubmit.ts
async function validateBeforeSubmit({
  setError,
  values,
  names,
  getFieldSchema,
  getFieldType,
  parents
}) {
  await Promise.all(
    names.map(async (name) => {
      const fieldSchema = getFieldSchema(name);
      const fieldType = getFieldType(fieldSchema);
      const dependencies = fieldSchema.getDependencies?.({
        values,
        phase: "serialize",
        getFieldSchema,
        getFieldType,
        parents
      });
      const validatorBeforeSubmit = fieldSchema.validatorBeforeSubmit || fieldType.validatorBeforeSubmit;
      if (validatorBeforeSubmit) {
        const computedGetFieldSchema = fieldType.createGetFieldSchema ? await fieldType.createGetFieldSchema({
          fieldSchema,
          getFieldSchema,
          getFieldType,
          values,
          phase: "serialize",
          parents,
          dependencies
        }) : getFieldSchema;
        await validatorBeforeSubmit({
          setError,
          setCurrentError: (error) => {
            setError(name, parents, error);
          },
          value: values[name],
          values,
          name,
          fieldSchema,
          getFieldSchema: computedGetFieldSchema,
          getFieldType,
          parents,
          dependencies
        });
      }
    })
  );
}

export {
  defaultParser,
  parse,
  parseSingle,
  defaultSerializer,
  serialize,
  serializeSingle,
  defaultFieldErrorsSetter,
  setFieldErrors,
  setValues,
  validateBeforeSubmit
};
//# sourceMappingURL=chunk-3DE3JEEE.js.map