extract-types.cjs

const ts = require('typescript');
const fs = require('fs');
const path = require('path');

function extractTypesFromModule(filePath) {
  const program = ts.createProgram([filePath], {});
  const checker = program.getTypeChecker();
  const sourceFile = program.getSourceFile(filePath);
  const seenTypes = new Set();

  const typeInfo = [];

  function visit(node) {
    if (ts.isModuleDeclaration(node) && node.name.text === 'vue-data-ui') {
      ts.forEachChild(node.body, visit);
    }

    if (ts.isInterfaceDeclaration(node)) {
      const interfaceName = node.name.text;
      const members = extractInterfaceMembers(node);

      typeInfo.push({
        kind: 'interface',
        name: interfaceName,
        members: members,
      });
    } else if (ts.isTypeAliasDeclaration(node)) {
      const typeName = node.name.text;
      const type = checker.getTypeAtLocation(node);
      const typeString = checker.typeToString(type);

      typeInfo.push({
        kind: 'type',
        name: typeName,
        type: typeString,
        details: extractTypeDetails(type),
      });
    } else if (ts.isEnumDeclaration(node)) {
      const enumName = node.name.text;
      const members = node.members.map(member => member.name.getText());

      typeInfo.push({
        kind: 'enum',
        name: enumName,
        members: members,
      });
    }
  }

  function extractInterfaceMembers(node) {
    const members = [];

    node.members.forEach(member => {
      const memberName = member.name.getText();
      const memberType = checker.getTypeAtLocation(member);
      const memberTypeString = checker.typeToString(memberType);
      const details = extractTypeDetails(memberType);

      members.push({
        name: memberName,
        type: memberTypeString,
        optional: member.questionToken ? true : false,
        isReadonly: member.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ReadonlyKeyword) || false,
        details: details,
      });
    });

    return members;
  }

  function extractTypeDetails(type) {
    const typeId = checker.typeToString(type);
    if (seenTypes.has(typeId)) {
      return { name: typeId, circular: true };
    }
    seenTypes.add(typeId);

    if (type.flags & ts.TypeFlags.Union) {
      return {
        kind: 'union',
        types: type.types.map(t => checker.typeToString(t)),
      };
    } else if (type.flags & ts.TypeFlags.Intersection) {
      return {
        kind: 'intersection',
        types: type.types.map(t => checker.typeToString(t)),
      };
    } else if (type.flags & ts.TypeFlags.Object) {
      return extractObjectTypeDetails(type);
    }
    return { name: checker.typeToString(type) };
  }

  function extractObjectTypeDetails(type) {
    const properties = type.getProperties();
    const details = [];

    properties.forEach(prop => {
      const propType = checker.getTypeOfSymbolAtLocation(prop, prop.valueDeclaration);
      const propTypeString = checker.typeToString(propType);
      const optional = prop.flags & ts.SymbolFlags.Optional;

      details.push({
        name: prop.getName(),
        type: propTypeString,
        optional: optional,
        details: extractTypeDetails(propType),
      });
    });

    return { kind: 'object', properties: details };
  }

  ts.forEachChild(sourceFile, visit);
  return typeInfo;
}

const filePath = path.resolve(__dirname, 'node_modules/vue-data-ui/dist/types/vue-data-ui.d.ts');

if (!fs.existsSync(filePath)) {
  console.error('File does not exist:', filePath);
  process.exit(1);
}

const types = extractTypesFromModule(filePath);

if (types.length === 0) {
  console.warn('No types found in the .d.ts file');
} else {
  fs.writeFileSync('types.json', JSON.stringify(types, null, 2));
  console.log('Type information extracted and written to types.json');
}