valibot-to-ts

valibot-to-ts.ts

const genPadding = (layer: number) =>
  new Array(layer).fill("  ").flat().join("");

function genObject({object}: any, layer: number) {
  const entries = Object.entries(object);
  let result = "{\n";
  const padding = genPadding(layer);
  for (const [key, value] of entries) {
    result += padding;
    result += `${key}: ${valibotToTs(value, layer + 1)},\n`;
  }
  result += genPadding(layer - 1);
  result += "}";
  return result;
}

function genTuple({tuple}: any, layer: number) {
  const {items, rest} = tuple;
  let result = "[";
  for (let i = 0; i < items.length; i++) {
    result += `${valibotToTs(items[i], layer + 1)}`;
    if (i < items.length - 1 || rest) result += ", ";
  }
  if (rest) result += `...${valibotToTs(rest, layer)}`;
  result += "]";
  return result;
}

function genUnion({union}: any, layer: number) {
  let result = "";
  for (let i = 0; i < union.length; i++) {
    result += `${valibotToTs(union[i], layer)}`;
    if (i < union.length - 1) result += " | ";
  }
  return result;
}

function genIntersection({intersection}: any, layer: number) {
  let result = "";
  for (let i = 0; i < intersection.length; i++) {
    result += `${valibotToTs(intersection[i], layer)}`;
    if (i < intersection.length - 1) result += " & ";
  }
  return result;
}

function valibotToTs(value: any, layer = 1): string {
  switch (value.schema) {
    case "object":
      return genObject(value, layer);
    case "intersection":
      return genIntersection(value, layer);
    case "tuple":
      return genTuple(value, layer);
    case "union":
      return genUnion(value, layer);
    case "array":
      return `${valibotToTs(value.array.item, layer)}[]`;
    case "literal":
      return `${value.literal.toString()}n`;
    case "set":
      return `Set<${valibotToTs(value.set.value, layer)}>`;
    case "record":
      return `Record<string, ${valibotToTs(value.record.value, layer)}>`;
    case "map":
      return `Map<${valibotToTs(value.map.key, layer)}, ${valibotToTs(
        value.map.value,
        layer,
      )}>`;
    case "blob":
      return "Blob";
    case "date":
      return "Date";
    case "nan":
      return "number";
    case "any":
    case "bigint":
    case "never":
    case "null":
    case "number":
    case "undefined":
    case "unknown":
    case "string":
    case "symbol":
    case "void":
      return value.schema;
    default:
      console.error("NOT IMPLEMENTED YET:", value, value.schema);
      return "";
  }
}