compileToTypeScriptType method

Future<String> compileToTypeScriptType(BuildContext? ctx, String fieldName, DartType type, List<String> refs, List<CodeBuffer> ext, BuildStep buildStep,)

Implementation

Future<String> compileToTypeScriptType(
    BuildContext? ctx,
    String fieldName,
    DartType type,
    List<String> refs,
    List<CodeBuffer> ext,
    BuildStep buildStep) async {
  var typeScriptType = 'any';

  var types = const {
    num: 'number',
    bool: 'boolean',
    String: 'string',
    Symbol: 'Symbol',
  };

  types.forEach((t, tsType) {
    if (TypeChecker.fromRuntime(t).isAssignableFromType(type)) {
      typeScriptType = tsType;
    }
  });

  if (type is InterfaceType) {
    if (isListOfModelType(type)) {
      var arg = await compileToTypeScriptType(
          ctx, fieldName, type.typeArguments[0], refs, ext, buildStep);
      typeScriptType = '$arg[]';
    } else if (const TypeChecker.fromRuntime(Map)
            .isAssignableFromType(type) &&
        type.typeArguments.length == 2) {
      var key = await compileToTypeScriptType(
          ctx, fieldName, type.typeArguments[0], refs, ext, buildStep);
      var value = await compileToTypeScriptType(
          ctx, fieldName, type.typeArguments[1], refs, ext, buildStep);
      //var modelType = type.typeArguments[1];
      /*var innerCtx = await buildContext(
      modelType.element,
      ConstantReader(
          serializableTypeChecker.firstAnnotationOf(modelType.element)),
      buildStep,
      buildStep.resolver,
      autoSnakeCaseNames,
      true,
    );*/

      typeScriptType =
          ctx!.modelClassNameRecase.pascalCase + ReCase(fieldName).pascalCase;

      ext.add(CodeBuffer()
        ..writeln('interface $typeScriptType {')
        ..indent()
        ..writeln('[key: $key]: $value;')
        ..outdent()
        ..writeln('}'));
    } else if (const TypeChecker.fromRuntime(List)
        .isAssignableFromType(type)) {
      if (type.typeArguments.isEmpty) {
        typeScriptType = 'any[]';
      } else {
        var arg = await compileToTypeScriptType(
            ctx, fieldName, type.typeArguments[0], refs, ext, buildStep);
        typeScriptType = '$arg[]';
      }
    } else if (isModelClass(type)) {
      var sourcePath = buildStep.inputId.uri.toString();
      var targetPath = type.element.source.uri.toString();

      if (!p.equals(sourcePath, targetPath)) {
        var relative = p.relative(targetPath, from: sourcePath);
        String? ref;

        if (type.element.source.uri.scheme == 'asset') {
          var id =
              AssetId.resolve(Uri.parse(type.element.source.uri.toString()));
          if (id.package != buildStep.inputId.package) {
            ref = '/// <reference types="${id.package}" />';
          }
        }

        if (ref == null) {
          // var relative = (p.dirname(targetPath) == p.dirname(sourcePath))
          //     ? p.basename(targetPath)
          //     : p.relative(targetPath, from: sourcePath);
          var parent = p.dirname(relative);
          var filename =
              p.setExtension(p.basenameWithoutExtension(relative), '.d.ts');
          relative = p.joinAll(p.split(parent).toList()..add(filename));
          ref = '/// <reference path="$relative" />';
        }
        if (!refs.contains(ref)) refs.add(ref);
      }

      var ctx = await buildContext(
        type.element,
        ConstantReader(
            serializableTypeChecker.firstAnnotationOf(type.element)),
        buildStep,
        buildStep.resolver,
        autoSnakeCaseNames,
      );

      typeScriptType = ctx?.modelClassNameRecase.pascalCase ?? 'any';
    }
  }

  return typeScriptType;
}