@lowgular/code-graph 0.1.1 → 0.1.2

package/codegular/string.js

@@ -1,121 +0,0 @@
-import * as ts from "typescript";
-import { findChildrenByKind } from "./utils.js";
-const { SyntaxKind } = ts;
-const throwUndefined = (val, message) => {
-  if (val === void 0) {
-    throw new Error(message);
-  }
-  return val;
-};
-const getText = (n) => n.getText(n.getSourceFile());
-const getTextOrThrow = (n) => throwUndefined(getText(n), `Could not get text`);
-const getNameByIdentifier = (n) => {
-  if (n.kind === SyntaxKind.Identifier) {
-    return getText(n);
-  }
-  const [nameNode] = findChildrenByKind(n, SyntaxKind.Identifier);
-  return nameNode ? getText(nameNode) : void 0;
-};
-const getInitializerText = (node) => {
-  return getText(node.initializer);
-};
-const getPropertyType = (node) => {
-  const typeNode = node.type;
-  if (typeNode) {
-    return typeNode.getText(node.getSourceFile());
-  }
-  return void 0;
-};
-function getTypeFromInitializer(initializer) {
-  if (ts.isStringLiteral(initializer)) {
-    return "string";
-  }
-  if (ts.isNumericLiteral(initializer)) {
-    return "number";
-  }
-  if (initializer.kind === ts.SyntaxKind.TrueKeyword || initializer.kind === ts.SyntaxKind.FalseKeyword) {
-    return "boolean";
-  }
-  if (ts.isArrayLiteralExpression(initializer)) {
-    return "any[]";
-  }
-  if (ts.isObjectLiteralExpression(initializer)) {
-    return "object";
-  }
-  if (ts.isIdentifier(initializer)) {
-    return initializer.text;
-  }
-  if (ts.isCallExpression(initializer)) {
-    return "any";
-  }
-  if ("members" in initializer && initializer.members) {
-    return "object";
-  }
-  return "any";
-}
-const getRange = (n) => {
-  const s = n.getSourceFile();
-  return {
-    start: s.getLineAndCharacterOfPosition(n.getStart()),
-    end: s.getLineAndCharacterOfPosition(n.getEnd())
-  };
-};
-const getFilePath = (n) => {
-  return n.getSourceFile().fileName;
-};
-const getStartLine = (n) => {
-  const s = n.getSourceFile();
-  return s.getLineAndCharacterOfPosition(n.getStart()).line;
-};
-const getEndLine = (n) => {
-  const s = n.getSourceFile();
-  return s.getLineAndCharacterOfPosition(n.getEnd()).line;
-};
-const getEndCharacter = (n) => {
-  const s = n.getSourceFile();
-  return s.getLineAndCharacterOfPosition(n.getEnd()).character;
-};
-const getStartCharacter = (n) => {
-  const s = n.getSourceFile();
-  return s.getLineAndCharacterOfPosition(n.getStart()).character;
-};
-function rangeDistance(outer, inner) {
-  function toFlat(x) {
-    return x.line * 1e6 + x.character;
-  }
-  const startDistance = toFlat(inner.start) - toFlat(outer.start);
-  const endDistance = toFlat(outer.end) - toFlat(inner.end);
-  if (startDistance < 0 || endDistance < 0) {
-    console.log("rangeDistance: ", startDistance, endDistance);
-    return void 0;
-  }
-  return startDistance + endDistance;
-}
-const getNameAndRange = (n) => {
-  const [nameNode] = findChildrenByKind(n, SyntaxKind.Identifier);
-  if (!nameNode) {
-    return void 0;
-  }
-  return {
-    text: getText(nameNode),
-    range: getRange(nameNode)
-  };
-};
-const getNameOrThrow = (n) => throwUndefined(getNameByIdentifier(n), `Could not get name`);
-export {
-  getEndCharacter,
-  getEndLine,
-  getFilePath,
-  getInitializerText,
-  getNameAndRange,
-  getNameByIdentifier,
-  getNameOrThrow,
-  getPropertyType,
-  getRange,
-  getStartCharacter,
-  getStartLine,
-  getText,
-  getTextOrThrow,
-  rangeDistance,
-  throwUndefined
-};

package/codegular/type-checker.js

@@ -1,133 +0,0 @@
-import * as ts from "typescript";
-const getDeclarationFromSymbol = (symbol, context) => {
-  let aliasedSymbol = symbol;
-  try {
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      aliasedSymbol = context.typeChecker.getAliasedSymbol(symbol) || symbol;
-    }
-  } catch (error) {
-    aliasedSymbol = symbol;
-  }
-  const declarations = aliasedSymbol.getDeclarations();
-  if (declarations && declarations.length > 0) {
-    return declarations[declarations.length - 1];
-  }
-  return aliasedSymbol.valueDeclaration;
-};
-const getDeclarationFromType = (type, context) => {
-  if (type.aliasSymbol) {
-    const aliasDeclarations = type.aliasSymbol.getDeclarations();
-    if (aliasDeclarations && aliasDeclarations.length > 0) {
-      return aliasDeclarations[aliasDeclarations.length - 1];
-    }
-    if (type.aliasSymbol.valueDeclaration) {
-      return type.aliasSymbol.valueDeclaration;
-    }
-  }
-  const baseType = type.target || type;
-  const typeSymbol = baseType.symbol;
-  if (typeSymbol) {
-    const declarations = typeSymbol.getDeclarations();
-    if (declarations && declarations.length > 0) {
-      return declarations[declarations.length - 1];
-    }
-    if (typeSymbol.valueDeclaration) {
-      return typeSymbol.valueDeclaration;
-    }
-  }
-  return void 0;
-};
-const getDeclarationFromTypeReference = (node, context) => {
-  const symbol = context.typeChecker.getSymbolAtLocation(node.typeName);
-  if (!symbol) {
-    return void 0;
-  }
-  return getDeclarationFromSymbol(symbol, context);
-};
-const getDeclarationFromValueSymbol = (node, context) => {
-  const symbol = context.typeChecker.getSymbolAtLocation(node);
-  if (!symbol) {
-    return void 0;
-  }
-  return getDeclarationFromSymbol(symbol, context);
-};
-const getDeclarationFromTypeLocation = (node, context) => {
-  try {
-    const type = context.typeChecker.getTypeAtLocation(node);
-    if (!type) {
-      return void 0;
-    }
-    return getDeclarationFromType(type, context);
-  } catch (error) {
-    return void 0;
-  }
-};
-const getDeclarationsFromSymbol = (symbol, context) => {
-  let aliasedSymbol = symbol;
-  try {
-    if (symbol.flags & ts.SymbolFlags.Alias) {
-      aliasedSymbol = context.typeChecker.getAliasedSymbol(symbol) || symbol;
-    }
-  } catch (error) {
-    aliasedSymbol = symbol;
-  }
-  const declarations = aliasedSymbol.getDeclarations();
-  if (declarations && declarations.length > 0) {
-    return declarations;
-  }
-  if (aliasedSymbol.valueDeclaration) {
-    return [aliasedSymbol.valueDeclaration];
-  }
-  return [];
-};
-const getDeclarations = (node, typeChecker) => {
-  if ("kind" in node) {
-    const currentNode = node;
-    if (ts.isTypeReferenceNode(node)) {
-      const symbol = typeChecker.getSymbolAtLocation(node.typeName);
-      if (symbol) {
-        return getDeclarationsFromSymbol(symbol, { typeChecker });
-      }
-      return [];
-    }
-    try {
-      const symbol = typeChecker.getSymbolAtLocation(currentNode);
-      if (symbol) {
-        return getDeclarationsFromSymbol(symbol, { typeChecker });
-      }
-    } catch (error) {
-    }
-    try {
-      const type2 = typeChecker.getTypeAtLocation(currentNode);
-      if (type2) {
-        return getDeclarations(type2, typeChecker);
-      }
-    } catch (error) {
-    }
-    return [];
-  }
-  const type = node;
-  const declarations = [];
-  if (type.aliasSymbol) {
-    const aliasDeclarations = type.aliasSymbol.getDeclarations();
-    if (aliasDeclarations && aliasDeclarations.length > 0) {
-      declarations.push(...aliasDeclarations);
-    } else if (type.aliasSymbol.valueDeclaration) {
-      declarations.push(type.aliasSymbol.valueDeclaration);
-    }
-  }
-  const baseType = type.target || type;
-  const typeSymbol = baseType.symbol;
-  if (typeSymbol) {
-    const typeDecls = getDeclarationsFromSymbol(typeSymbol, { typeChecker });
-    declarations.push(...typeDecls);
-  }
-  return declarations;
-};
-export {
-  getDeclarationFromType,
-  getDeclarationFromTypeLocation,
-  getDeclarationFromTypeReference,
-  getDeclarationFromValueSymbol,
-  getDeclarations
-};

package/codegular/type.js

@@ -1,356 +0,0 @@
-import * as ts from "typescript";
-import { getDeclarationFromType } from "./type-checker";
-var TypeInfoAbstraction = /* @__PURE__ */ ((TypeInfoAbstraction2) => {
-  TypeInfoAbstraction2["VOID"] = "VoidType";
-  TypeInfoAbstraction2["NULLISH"] = "NullishType";
-  TypeInfoAbstraction2["PRIMITIVE"] = "PrimitiveType";
-  TypeInfoAbstraction2["OBJECT"] = "ObjectType";
-  TypeInfoAbstraction2["FUNCTION"] = "FunctionType";
-  TypeInfoAbstraction2["DECLARATION"] = "DeclarationType";
-  TypeInfoAbstraction2["UNKNOWN"] = "unknown";
-  return TypeInfoAbstraction2;
-})(TypeInfoAbstraction || {});
-const resolveFromType = (type, typeChecker) => {
-  if (type.flags & ts.TypeFlags.Void) {
-    return {
-      abstraction: "VoidType" /* VOID */,
-      declaration: void 0
-    };
-  }
-  if (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) {
-    return {
-      abstraction: "NullishType" /* NULLISH */,
-      declaration: void 0
-    };
-  }
-  if (type.flags & (ts.TypeFlags.String | ts.TypeFlags.Number | ts.TypeFlags.Boolean | ts.TypeFlags.BigInt | ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol | ts.TypeFlags.StringLiteral | ts.TypeFlags.NumberLiteral | ts.TypeFlags.BooleanLiteral | ts.TypeFlags.BigIntLiteral)) {
-    return {
-      abstraction: "PrimitiveType" /* PRIMITIVE */,
-      declaration: void 0
-    };
-  }
-  const declaration = getDeclarationFromType(type, {
-    typeChecker
-  });
-  if (declaration) {
-    if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
-      return {
-        abstraction: "DeclarationType" /* DECLARATION */,
-        declaration
-      };
-    }
-  }
-  if (type.getCallSignatures().length > 0) {
-    return {
-      abstraction: "FunctionType" /* FUNCTION */,
-      declaration: void 0
-    };
-  }
-  if (type.flags & ts.TypeFlags.Object) {
-    return {
-      abstraction: "ObjectType" /* OBJECT */,
-      declaration: void 0
-    };
-  }
-  return {
-    abstraction: "unknown" /* UNKNOWN */,
-    declaration: void 0
-  };
-};
-class TypeResolutionTracker {
-  constructor() {
-    // Cache for resolved types - maps ts.Type to TypeInfoImpl
-    this._typeCache = /* @__PURE__ */ new WeakMap();
-    // Cache for resolved types from nodes - maps ts.Node to TypeInfoImpl
-    this._nodeCache = /* @__PURE__ */ new WeakMap();
-  }
-  /**
-   * Gets the cached TypeInfoImpl for a type, or undefined if not cached.
-   */
-  get(type) {
-    return this._typeCache.get(type);
-  }
-  /**
-   * Caches a TypeInfoImpl for a type.
-   */
-  set(type, value) {
-    this._typeCache.set(type, value);
-  }
-  /**
-   * Gets the cached TypeInfoImpl for a node, or undefined if not cached.
-   */
-  getFromNode(node) {
-    return this._nodeCache.get(node);
-  }
-  /**
-   * Caches a TypeInfoImpl for a node.
-   */
-  setFromNode(node, value) {
-    this._nodeCache.set(node, value);
-  }
-}
-const cacheDecorator = (cb, node, typeResolutionTracker) => {
-  const cached = typeResolutionTracker.getFromNode(node);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const result = cb(node);
-  if (result) {
-    typeResolutionTracker.setFromNode(node, result);
-  }
-  return result;
-};
-const getType = (node, typeChecker, typeResolutionTracker) => {
-  const context = {
-    typeChecker,
-    typeResolutionTracker
-  };
-  const typeImpl = cacheDecorator(
-    (node2) => {
-      try {
-        if (ts.isMethodDeclaration(node2)) {
-          return fromMethodReturnType(node2, context);
-        }
-        if (ts.isPropertyDeclaration(node2)) {
-          if (node2.type) {
-            return fromTsNode(node2.type, context);
-          }
-          if (node2.initializer) {
-            return fromPropertyInitializer(node2.initializer, context);
-          }
-          return void 0;
-        }
-        if (ts.isTypeNode(node2)) {
-          return fromExplicitTypeAnnotation(node2, context);
-        }
-        if (ts.isExpression(node2)) {
-          return fromPropertyInitializer(node2, context);
-        }
-        const type = context.typeChecker.getTypeAtLocation(node2);
-        if (!type) {
-          return void 0;
-        }
-        return fromInferredType(type, context);
-      } catch (error) {
-        console.error("error", error);
-        return void 0;
-      }
-    },
-    node,
-    typeResolutionTracker
-  );
-  if (!typeImpl) {
-    return [];
-  }
-  console.log("typeImpl", typeImpl.type.symbol?.name);
-  return [typeImpl.type];
-};
-function fromTsNode(node, context) {
-  return cacheDecorator(
-    (node2) => {
-      try {
-        if (ts.isMethodDeclaration(node2)) {
-          return fromMethodReturnType(node2, context);
-        }
-        if (ts.isPropertyDeclaration(node2)) {
-          if (node2.type) {
-            return fromTsNode(node2.type, context);
-          }
-          if (node2.initializer) {
-            return fromPropertyInitializer(node2.initializer, context);
-          }
-          return void 0;
-        }
-        if (ts.isTypeNode(node2)) {
-          return fromExplicitTypeAnnotation(node2, context);
-        }
-        if (ts.isExpression(node2)) {
-          return fromPropertyInitializer(node2, context);
-        }
-        const type = context.typeChecker.getTypeAtLocation(node2);
-        if (!type) {
-          return void 0;
-        }
-        return fromInferredType(type, context);
-      } catch (error) {
-        console.error("error", error);
-        return void 0;
-      }
-    },
-    node,
-    context.typeResolutionTracker
-  );
-}
-function fromMethodReturnType(methodNode, context) {
-  try {
-    const cached = context.typeResolutionTracker.getFromNode(methodNode);
-    if (cached !== void 0) {
-      return cached;
-    }
-    if (methodNode.type) {
-      const result = fromExplicitTypeAnnotation(methodNode.type, context);
-      if (result) {
-        context.typeResolutionTracker.setFromNode(methodNode, result);
-      }
-      return result;
-    }
-    const methodType = context.typeChecker.getTypeAtLocation(methodNode);
-    const signatures = methodType.getCallSignatures();
-    if (signatures.length > 0) {
-      const returnType = signatures[signatures.length - 1].getReturnType();
-      if (returnType.symbol) {
-        const result2 = fromTypeWithSymbol(returnType, context);
-        if (result2) {
-          context.typeResolutionTracker.setFromNode(methodNode, result2);
-        }
-        return result2;
-      }
-      const result = fromInferredType(returnType, context);
-      if (result) {
-        context.typeResolutionTracker.setFromNode(methodNode, result);
-      }
-      return result;
-    }
-    return void 0;
-  } catch (error) {
-    return void 0;
-  }
-}
-function fromPropertyInitializer(initializer, context) {
-  try {
-    const cached = context.typeResolutionTracker.getFromNode(
-      initializer
-    );
-    if (cached !== void 0) {
-      return cached;
-    }
-    if (ts.isIdentifier(initializer)) {
-      const symbol = context.typeChecker.getSymbolAtLocation(initializer);
-      if (symbol) {
-        const declarations = symbol.getDeclarations();
-        const varDecl = declarations?.find((d) => ts.isVariableDeclaration(d));
-        if (varDecl) {
-          const varType = varDecl.initializer ? context.typeChecker.getTypeAtLocation(varDecl.initializer) : context.typeChecker.getTypeAtLocation(varDecl);
-          if (varType) {
-            const result2 = fromInferredType(varType, context);
-            if (result2) {
-              context.typeResolutionTracker.setFromNode(initializer, result2);
-            }
-            return result2;
-          }
-        }
-      }
-    }
-    const type = context.typeChecker.getTypeAtLocation(initializer);
-    if (!type) {
-      return void 0;
-    }
-    const result = fromInferredType(type, context);
-    if (result) {
-      context.typeResolutionTracker.setFromNode(initializer, result);
-    }
-    return result;
-  } catch (error) {
-    return void 0;
-  }
-}
-function fromTypeWithSymbol(type, context) {
-  try {
-    const cached = context.typeResolutionTracker.get(type);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const baseType = type.target || type;
-    const typeSymbol = baseType.symbol;
-    if (typeSymbol) {
-      const declarations = typeSymbol.getDeclarations();
-      const declaration = declarations && declarations.length > 0 ? declarations[declarations.length - 1] : typeSymbol.valueDeclaration;
-      if (declaration) {
-        if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
-          return new TypeImplementation(
-            type,
-            // TypeInfoAbstraction.DECLARATION,
-            declaration,
-            void 0,
-            context
-          );
-        }
-      }
-    }
-    return void 0;
-  } catch (error) {
-    return void 0;
-  }
-}
-function fromInferredType(type, context) {
-  try {
-    const cached = context.typeResolutionTracker.get(type);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const resolved = resolveFromType(type, context.typeChecker);
-    const typeArgs = type.typeArguments;
-    const typeArguments = typeArgs ? typeArgs.map((arg) => fromInferredType(arg, context)).filter((arg) => arg !== void 0) : void 0;
-    const result = new TypeImplementation(
-      type,
-      // resolved.abstraction,
-      resolved.declaration,
-      typeArguments,
-      context
-    );
-    context.typeResolutionTracker.set(type, result);
-    return result;
-  } catch (error) {
-    return void 0;
-  }
-}
-function fromExplicitTypeAnnotation(typeNode, context) {
-  try {
-    if (ts.isTypeReferenceNode(typeNode)) {
-      const declaration = void 0;
-      if (declaration) {
-        if (ts.isTypeAliasDeclaration(declaration) || ts.isInterfaceDeclaration(declaration) || ts.isClassDeclaration(declaration) || ts.isEnumDeclaration(declaration) || ts.isVariableDeclaration(declaration) || ts.isFunctionDeclaration(declaration)) {
-          const underlyingType = context.typeChecker.getTypeAtLocation(typeNode);
-          const typeArgs = underlyingType && underlyingType.typeArguments;
-          const typeArguments = typeArgs ? typeArgs.map((arg) => fromInferredType(arg, context)).filter((arg) => arg !== void 0) : void 0;
-          return new TypeImplementation(
-            underlyingType,
-            // TypeInfoAbstraction.DECLARATION,
-            declaration,
-            typeArguments,
-            context
-          );
-        }
-      }
-    }
-    const type = context.typeChecker.getTypeAtLocation(typeNode);
-    if (!type) {
-      return void 0;
-    }
-    return fromInferredType(type, context);
-  } catch (error) {
-    return void 0;
-  }
-}
-class TypeImplementation {
-  // public readonly typeArgumentAbstraction: TypeInfoAbstraction | undefined;
-  constructor(type, declaration, typeArguments, context) {
-    this.type = type;
-    this.baseTypes = [];
-    this.name = context.typeChecker.typeToString(type);
-    const baseTypes = type.getBaseTypes();
-    if (baseTypes) {
-      this.baseTypes = baseTypes.map((baseType) => {
-        return fromInferredType(baseType, context);
-      });
-    }
-    this.kind = "Type";
-    this.typeArguments = typeArguments;
-  }
-}
-export {
-  TypeInfoAbstraction,
-  TypeResolutionTracker,
-  cacheDecorator,
-  getType
-};