@tanstack/ai-code-mode/dist/esm/type-generator/json-schema-to-ts.js

Code Mode for TanStack AI - LLM-driven code execution in secure sandboxes

function generateTypeStubs(bindings, options = {}) {
  const { includeDescriptions = true } = options;
  const declarations = [];
  for (const [name, binding] of Object.entries(bindings)) {
    const inputTypeName = `${capitalize(name)}Input`;
    const outputTypeName = `${capitalize(name)}Output`;
    const inputType = jsonSchemaToTypeScript(binding.inputSchema, inputTypeName);
    if (inputType.declaration) {
      declarations.push(inputType.declaration);
    }
    let outputTypeRef = "unknown";
    if (binding.outputSchema) {
      const outputType = jsonSchemaToTypeScript(
        binding.outputSchema,
        outputTypeName
      );
      if (outputType.declaration) {
        declarations.push(outputType.declaration);
      }
      outputTypeRef = outputType.name;
    }
    const description = includeDescriptions && binding.description ? `/** ${binding.description} */
` : "";
    declarations.push(
      `${description}declare function ${name}(input: ${inputType.name}): Promise<${outputTypeRef}>;`
    );
  }
  return declarations.join("\n\n");
}
function jsonSchemaToTypeScript(schema, typeName) {
  const type = schemaToType(schema);
  if (schema.type === "object" && schema.properties && Object.keys(schema.properties).length > 0) {
    return {
      name: typeName,
      declaration: `interface ${typeName} ${type}`
    };
  }
  return {
    name: type,
    declaration: ""
  };
}
function schemaToType(schema) {
  if (typeof schema !== "object") {
    return "unknown";
  }
  const schemaType = schema.type;
  if (schemaType === "string") return "string";
  if (schemaType === "number" || schemaType === "integer") return "number";
  if (schemaType === "boolean") return "boolean";
  if (schemaType === "null") return "null";
  if (schemaType === "array") {
    const items = schema.items;
    const itemType = items ? schemaToType(items) : "unknown";
    return `Array<${itemType}>`;
  }
  if (schemaType === "object" && schema.properties) {
    const properties = schema.properties;
    const required = new Set(
      schema.required ?? []
    );
    const props = Object.entries(properties).map(([key, propSchema]) => {
      const optional = required.has(key) ? "" : "?";
      const propType = schemaToType(propSchema);
      const safeName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
      return `  ${safeName}${optional}: ${propType};`;
    }).join("\n");
    return `{
${props}
}`;
  }
  if (schema.enum) {
    const enumValues = schema.enum;
    return enumValues.map((v) => JSON.stringify(v)).join(" | ");
  }
  if (schema.anyOf || schema.oneOf) {
    const variants = schema.anyOf || schema.oneOf;
    return variants.map((v) => schemaToType(v)).join(" | ");
  }
  if (Array.isArray(schemaType)) {
    return schemaType.map((t) => {
      if (t === "string") return "string";
      if (t === "number" || t === "integer") return "number";
      if (t === "boolean") return "boolean";
      if (t === "null") return "null";
      if (t === "array") return "Array<unknown>";
      if (t === "object") return "object";
      return "unknown";
    }).join(" | ");
  }
  return "unknown";
}
function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
}
export {
  generateTypeStubs,
  jsonSchemaToTypeScript
};
//# sourceMappingURL=json-schema-to-ts.js.map