@teambit/typescript 0.0.0-02c0c8ffc2ebaf66ef5cbfc2e31c48e2b4acbfc7

package/dist/schema-extractor-context.js

@@ -0,0 +1,745 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SchemaExtractorContext = void 0;
+function _tsutils() {
+  const data = require("tsutils");
+  _tsutils = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireWildcard(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.utils");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _semanticsEntities() {
+  const data = require("@teambit/semantics.entities.semantic-schema");
+  _semanticsEntities = function () {
+    return data;
+  };
+  return data;
+}
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+  _pMapSeries = function () {
+    return data;
+  };
+  return data;
+}
+function _identifierList() {
+  const data = require("./identifier-list");
+  _identifierList = function () {
+    return data;
+  };
+  return data;
+}
+function _parseTypeFromQuickInfo() {
+  const data = require("./transformers/utils/parse-type-from-quick-info");
+  _parseTypeFromQuickInfo = function () {
+    return data;
+  };
+  return data;
+}
+function _jsdocToDocSchema() {
+  const data = require("./transformers/utils/jsdoc-to-doc-schema");
+  _jsdocToDocSchema = function () {
+    return data;
+  };
+  return data;
+}
+function _identifier() {
+  const data = require("./identifier");
+  _identifier = function () {
+    return data;
+  };
+  return data;
+}
+function _exportIdentifier() {
+  const data = require("./export-identifier");
+  _exportIdentifier = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // @ts-ignore david we should figure fix this.
+// eslint-disable-next-line import/no-unresolved
+class SchemaExtractorContext {
+  get mainFile() {
+    return (0, _legacy().pathNormalizeToLinux)(this.getPathRelativeToComponent(this.component.mainFile.path));
+  }
+  get identifiers() {
+    return this._identifiers;
+  }
+  get internalIdentifiers() {
+    return this._internalIdentifiers;
+  }
+  get computed() {
+    return this._computed;
+  }
+  get mainFileIdentifierKey() {
+    const mainFile = this.component.mainFile;
+    return this.getIdentifierKey(mainFile.path);
+  }
+  get mainModuleIdentifiers() {
+    return this.identifiers.get(this.mainFileIdentifierKey);
+  }
+  constructor(tsserver, component, extractor, componentDeps, componentRootPath, hostRootPath, formatter) {
+    this.tsserver = tsserver;
+    this.component = component;
+    this.extractor = extractor;
+    this.componentDeps = componentDeps;
+    this.componentRootPath = componentRootPath;
+    this.hostRootPath = hostRootPath;
+    this.formatter = formatter;
+    /**
+     * list of all declared identifiers (exported and internal) by filename
+     */
+    _defineProperty(this, "_identifiers", new Map());
+    _defineProperty(this, "_internalIdentifiers", new Map());
+    /**
+     * computed nodes by filename and (position (line:character))
+     */
+    _defineProperty(this, "_computed", new Map());
+    this.componentRootPath = (0, _legacy().pathNormalizeToLinux)(componentRootPath);
+    this.hostRootPath = (0, _legacy().pathNormalizeToLinux)(hostRootPath);
+  }
+  getComputedNodeKey({
+    filePath,
+    line,
+    character
+  }, schema) {
+    return `${filePath}:${line}:${character}__${schema}`;
+  }
+  getIdentifierKeyForNode(node) {
+    const filePath = node.getSourceFile().fileName;
+    return this.getIdentifierKey(filePath);
+  }
+  getIdentifierKey(filePath) {
+    return (0, _legacy().pathNormalizeToLinux)(filePath);
+  }
+  setComputed(node) {
+    const {
+      location,
+      __schema
+    } = node;
+    const key = this.getComputedNodeKey(location, __schema);
+    this.computed.set(key, node);
+  }
+  setIdentifiers(filePath, identifiers) {
+    this._identifiers.set(this.getIdentifierKey(filePath), identifiers);
+  }
+  setInternalIdentifiers(filePath, identifiers) {
+    const existing = this._internalIdentifiers.get(filePath);
+    if (!existing) {
+      this._internalIdentifiers.set(filePath, identifiers);
+    } else {
+      const uniqueIdentifiers = (0, _lodash().uniqBy)(existing.identifiers.concat(identifiers.identifiers), k => k.aliasId || k.id);
+      this._internalIdentifiers.set(filePath, new (_identifierList().IdentifierList)(uniqueIdentifiers));
+    }
+  }
+  findComputedSchemaByName(name) {
+    const computed = Array.from(this.computed.values());
+    return computed.filter(schema => schema.name === name);
+  }
+  async computeSchema(node) {
+    const location = this.getLocation(node);
+    const key = this.getComputedNodeKey(location, _typescript().SyntaxKind[node.kind]);
+    const existingComputedSchema = this.computed.get(key);
+    if (existingComputedSchema) {
+      return existingComputedSchema;
+    }
+    const computedSchema = await this.extractor.computeSchema(node, this);
+    this.setComputed(computedSchema);
+    return computedSchema;
+  }
+  async transformSchemaNode(schema) {
+    return this.extractor.transformAPI(schema, this);
+  }
+
+  /**
+   * returns the location of a node in a source file.
+   */
+  getLocation(node, targetSourceFile, absolutePath = false) {
+    const sourceFile = targetSourceFile || node.getSourceFile();
+    const filePath = absolutePath ? sourceFile.fileName : this.getPathRelativeToComponent(sourceFile.fileName);
+    const position = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+    const line = position.line + 1;
+    const character = position.character + 1;
+    return {
+      filePath: (0, _legacy().pathNormalizeToLinux)(filePath),
+      line,
+      character
+    };
+  }
+  getLocationAsString(node) {
+    const location = this.getLocation(node);
+    return `${node.getSourceFile().fileName}, line: ${location.line}, character: ${location.character}`;
+  }
+  getPathRelativeToComponent(filePath) {
+    const basePath = this.component.filesystem.files[0].base;
+    return (0, _path().relative)(basePath, filePath);
+  }
+
+  /**
+   * returns a signature for a node.
+   */
+  async getSignature(node) {
+    return this.tsserver.getSignatureHelp(this.getPath(node), this.getLocation(node));
+  }
+
+  /**
+   * get the position for the tsserver.
+   */
+  getPosition(sourceFile, line, offset) {
+    return sourceFile.getPositionOfLineAndCharacter(line - 1, offset - 1);
+  }
+
+  /**
+   * get the path for a source file.
+   */
+  getPath(node) {
+    const sourceFile = node.getSourceFile();
+    const fileName = sourceFile.fileName;
+    if (!fileName.startsWith(this.componentRootPath) && !fileName.startsWith(this.hostRootPath)) {
+      return (0, _path().join)(this.componentRootPath, fileName);
+    }
+    return sourceFile.fileName;
+  }
+  async getQuickInfo(node) {
+    const location = this.getLocation(node);
+    try {
+      return await this.tsserver.getQuickInfo(this.getPath(node), location);
+    } catch (err) {
+      if (err.message === 'No content available.') {
+        throw new Error(`unable to get quickinfo data from tsserver at ${this.getPath(node)}, Ln ${location.line}, Col ${location.character}`);
+      }
+      throw err;
+    }
+  }
+  async getQuickInfoDisplayString(node) {
+    const quickInfo = await this.getQuickInfo(node);
+    return quickInfo?.body?.displayString || '';
+  }
+
+  /**
+   * returns the type definition for a type.
+   */
+  typeDefinition(node) {
+    return this.tsserver.getTypeDefinition(this.getPath(node), this.getLocation(node));
+  }
+  visitTypeDefinition() {}
+  getPathWithoutExtension(filePath) {
+    const knownExtensions = ['ts', 'js', 'jsx', 'tsx'];
+    const fileExtension = (0, _path().extname)(filePath).substring(1);
+    const filePathWithoutExtension = () => {
+      if (knownExtensions.includes(fileExtension)) {
+        return filePath.replace(new RegExp(`\\.${fileExtension}$`), '');
+      }
+      return filePath;
+    };
+    if (!(0, _path().isAbsolute)(filePath)) {
+      return filePathWithoutExtension();
+    }
+    if (filePath.startsWith(this.componentRootPath)) {
+      return (0, _path().relative)(this.componentRootPath, filePathWithoutExtension());
+    }
+    if (filePath.startsWith(this.hostRootPath)) {
+      return (0, _path().relative)(this.hostRootPath, filePathWithoutExtension());
+    }
+    return filePathWithoutExtension();
+  }
+  isIndexFile(filePath, currentFilePath) {
+    const indexFilePath = (0, _path().join)(filePath, 'index');
+    return (0, _legacy().pathNormalizeToLinux)(indexFilePath) === currentFilePath;
+  }
+  findFileInComponent(filePath) {
+    const normalizedFilePath = (0, _legacy().pathNormalizeToLinux)(filePath);
+    const pathToCompareWithoutExtension = this.getPathWithoutExtension(normalizedFilePath);
+    const matchingFile = this.component.filesystem.files.find(file => {
+      const currentFilePath = (0, _legacy().pathNormalizeToLinux)(file.path);
+      const currentFilePathWithoutExtension = this.getPathWithoutExtension(currentFilePath);
+      const isSameFilePath = pathToCompareWithoutExtension === currentFilePathWithoutExtension;
+      const matches = isSameFilePath || this.isIndexFile(pathToCompareWithoutExtension, currentFilePathWithoutExtension);
+      return matches;
+    });
+    return matchingFile;
+  }
+  parsePackageNameFromPath(path) {
+    const parts = path.split('node_modules');
+    if (parts.length === 1) {
+      return path;
+    }
+    const lastPart = parts[parts.length - 1].replace(_path().sep, '');
+    const pkgParts = lastPart.split('/');
+    if (lastPart.startsWith('@')) {
+      // scoped package
+      return `${pkgParts[0]}/${pkgParts[1]}`;
+    }
+    const pkgName = pkgParts[0];
+    if (pkgName === 'typescript') {
+      // it's a built-in type, such as "string".
+      return '';
+    }
+    return pkgName;
+  }
+
+  /**
+   * return the file if part of the component.
+   * otherwise, a reference to the target package and the type name.
+   */
+  getSourceFileInsideComponent(filePath) {
+    const file = this.findFileInComponent(filePath);
+    return file && this.extractor.parseSourceFile(file);
+  }
+  async getSourceFileFromNode(node) {
+    const filePath = await this.getFilePathByNode(node);
+    if (!filePath) {
+      return undefined;
+    }
+    return this.getSourceFileInsideComponent(filePath);
+  }
+  async getFilePathByNode(node) {
+    const def = await this.tsserver.getDefinition(this.getPath(node), this.getLocation(node));
+    const firstDef = (0, _lodash().head)(def?.body);
+    return firstDef?.file;
+  }
+  async definitionInfo(node) {
+    const location = this.getLocation(node);
+    const filePath = this.getPath(node);
+    const def = await this.tsserver.getDefinition(filePath, location);
+    const firstDef = (0, _lodash().head)(def?.body);
+    return firstDef;
+  }
+
+  /**
+   * get a definition for a given node.
+   */
+  async definition(definition) {
+    const startPosition = definition.start;
+    const sourceFile = this.getSourceFileInsideComponent(definition.file);
+    if (!sourceFile) {
+      // it might be an external reference, cant get the node
+      return undefined;
+    }
+    const pos = this.getPosition(sourceFile, startPosition.line, startPosition.offset);
+    const nodeAtPos = (0, _tsutils().getTokenAtPosition)(sourceFile, pos);
+    return nodeAtPos;
+  }
+
+  /**
+   * visit a definition for node - e.g. return it's schema.
+   */
+  async visitDefinition(node) {
+    const definitionInfo = await this.definitionInfo(node);
+    if (!definitionInfo) {
+      return undefined;
+    }
+    const definition = await this.definition(definitionInfo);
+    if (!definition) {
+      return this.getTypeRefForExternalNode(node);
+    }
+    return this.visit(definition.parent);
+  }
+  async visit(node) {
+    if (node.kind === _typescript().SyntaxKind.Identifier && node.parent.parent.kind !== _typescript().SyntaxKind.SourceFile) {
+      return this.visit(node.parent);
+    }
+    return this.extractor.computeSchema(node, this);
+  }
+  references() {}
+  isExported() {}
+  isFromComponent() {}
+  async getFileIdentifiers(exportDec) {
+    const file = exportDec.getSourceFile().fileName;
+    const specifierPathStr = exportDec.kind === _typescript().SyntaxKind.ExportDeclaration && exportDec.moduleSpecifier?.getText() || '';
+    const specifierPath = specifierPathStr.substring(1, specifierPathStr.length - 1);
+    const absPath = (0, _path().resolve)(file, '..', specifierPath);
+    const sourceFile = this.getSourceFileInsideComponent(absPath);
+    if (!sourceFile) return [];
+    return this.getIdentifiers(sourceFile);
+  }
+  async getFileExports(exportDec) {
+    const identifiers = await this.getFileIdentifiers(exportDec);
+    return identifiers.filter(identifier => _exportIdentifier().ExportIdentifier.isExportIdentifier(identifier));
+  }
+  async getFileInternals(exportDec) {
+    const identifiers = await this.getFileIdentifiers(exportDec);
+    return identifiers.filter(identifier => !_exportIdentifier().ExportIdentifier.isExportIdentifier(identifier));
+  }
+  getIdentifiers(node) {
+    return this.extractor.computeIdentifiers(node, this);
+  }
+
+  /**
+   * tsserver has two different calls: "definition" and "typeDefinition".
+   * normally, we need the "typeDefinition" to get the type data of a node.
+   * sometimes, it has no data, for example when the node is of type TypeReference, and then using "definition" is
+   * helpful. (couldn't find a rule when to use each one. e.g. "VariableDeclaration" sometimes has data only in
+   * "definition" but it's not clear when/why).
+   */
+  async getDefinition(node) {
+    const typeDefinition = await this.typeDefinition(node);
+    const headTypeDefinition = (0, _lodash().head)(typeDefinition?.body);
+    if (headTypeDefinition) {
+      return headTypeDefinition;
+    }
+    const definition = await this.tsserver.getDefinition(node.getSourceFile().fileName, this.getLocation(node));
+    const headDefinition = (0, _lodash().head)(definition?.body);
+    return headDefinition;
+  }
+
+  /**
+   * Handles type resolution for unknown or external types.
+   * Attempts to:
+   * 1. Get type references when possible
+   * 2. Fall back to inference when references can't be found
+   */
+  async unknownExactType(node, location, typeStr = 'any') {
+    try {
+      if (this.isArrayType(typeStr)) {
+        const baseType = this.getArrayBaseType(typeStr);
+        const currentFilePath = node.getSourceFile().fileName;
+        const baseTypeRef = await this.getTypeRef(baseType, this.getIdentifierKey(currentFilePath), location);
+        if (baseTypeRef) {
+          return new (_semanticsEntities().TypeArraySchema)(location, baseTypeRef);
+        }
+        return new (_semanticsEntities().TypeArraySchema)(location, new (_semanticsEntities().InferenceTypeSchema)(location, baseType));
+      }
+      const currentFilePath = node.getSourceFile().fileName;
+      const typeRef = await this.getTypeRef(typeStr, this.getIdentifierKey(currentFilePath), location);
+      if (typeRef) {
+        return typeRef;
+      }
+      const info = await this.getQuickInfo(node);
+      if (!info?.body?.displayString) {
+        return new (_semanticsEntities().InferenceTypeSchema)(location, typeStr || 'any');
+      }
+      const {
+        displayString,
+        kind
+      } = info.body;
+      if (kind === 'method') {
+        const returnType = this.extractMethodReturnType(displayString);
+        return await this.createMethodReturnSchema(node, location, returnType);
+      }
+      if (kind === 'function' || displayString.includes('=>')) {
+        return await this.createFunctionSchema(node, location, displayString);
+      }
+      if (displayString.includes('{') && displayString.includes('}')) {
+        return this.createObjectSchema(node, location, displayString);
+      }
+      if (displayString.includes('Promise<')) {
+        const innerType = this.extractGenericType(displayString, 'Promise');
+        return await this.createPromiseSchema(node, location, innerType);
+      }
+      return new (_semanticsEntities().InferenceTypeSchema)(location, typeStr || 'any');
+    } catch {
+      return new (_semanticsEntities().InferenceTypeSchema)(location, typeStr || 'any');
+    }
+  }
+
+  /**
+   * Check if type is an array type (either T[] or Array<T>)
+   */
+  isArrayType(typeStr) {
+    return typeStr.endsWith('[]') || typeStr.startsWith('Array<');
+  }
+
+  /**
+   * Extract base type from array type
+   */
+  getArrayBaseType(typeStr) {
+    if (typeStr.endsWith('[]')) {
+      return typeStr.slice(0, -2);
+    }
+    if (typeStr.startsWith('Array<')) {
+      const match = /Array<(.+)>/.exec(typeStr);
+      return match?.[1] || 'any';
+    }
+    return typeStr;
+  }
+
+  /**
+   * Extract return type from method signature
+   */
+  extractMethodReturnType(displayString) {
+    const returnTypeMatch = displayString.match(/\):\s*(.+)$/);
+    return returnTypeMatch ? returnTypeMatch[1].trim() : 'any';
+  }
+
+  /**
+   * Extract content from generic type
+   */
+  extractGenericType(type, wrapper) {
+    const match = new RegExp(`${wrapper}<(.+)>`).exec(type);
+    return match ? match[1].trim() : type;
+  }
+
+  /**
+   * Create schema for method return type, attempting to get type reference
+   */
+  async createMethodReturnSchema(node, location, returnType) {
+    if (this.isArrayType(returnType)) {
+      const baseType = this.getArrayBaseType(returnType);
+      const currentFilePath = node.getSourceFile().fileName;
+      const baseTypeRef = await this.getTypeRef(baseType, this.getIdentifierKey(currentFilePath), location);
+      if (baseTypeRef) {
+        return new (_semanticsEntities().TypeArraySchema)(location, baseTypeRef);
+      }
+      return new (_semanticsEntities().TypeArraySchema)(location, new (_semanticsEntities().InferenceTypeSchema)(location, baseType));
+    }
+    const typeRef = await this.getTypeRef(returnType, this.getIdentifierKeyForNode(node), location);
+    return typeRef || new (_semanticsEntities().InferenceTypeSchema)(location, returnType);
+  }
+
+  /**
+   * Create schema for function type, handling params and return type
+   */
+  async createFunctionSchema(node, location, signature) {
+    const match = signature.match(/\((.*)\)\s*(?:=>|:)\s*(.+)/);
+    if (!match) {
+      return new (_semanticsEntities().FunctionLikeSchema)(location, 'anonymous', [], new (_semanticsEntities().InferenceTypeSchema)(location, 'any'), signature);
+    }
+    const [, paramsStr, returnTypeStr] = match;
+    const params = await this.createFunctionParameters(node, location, paramsStr);
+    const returnType = await this.createMethodReturnSchema(node, location, returnTypeStr.trim());
+    return new (_semanticsEntities().FunctionLikeSchema)(location, 'anonymous', params, returnType, signature);
+  }
+
+  /**
+   * Create parameters for function schema, attempting to get type references for param types
+   */
+  async createFunctionParameters(node, location, paramsStr) {
+    if (!paramsStr.trim()) return [];
+    const params = paramsStr.split(',');
+    const paramSchemas = [];
+    for (const param of params) {
+      const [nameWithOptional, type] = param.split(':').map(s => s.trim());
+      const isOptional = nameWithOptional.includes('?');
+      const name = nameWithOptional.replace('?', '');
+      if (!type) {
+        paramSchemas.push(new (_semanticsEntities().ParameterSchema)(location, name, new (_semanticsEntities().InferenceTypeSchema)(location, 'any'), isOptional));
+        continue;
+      }
+      const currentFilePath = node.getSourceFile().fileName;
+      const typeRef = await this.getTypeRef(type, this.getIdentifierKey(currentFilePath), location);
+      paramSchemas.push(new (_semanticsEntities().ParameterSchema)(location, name, typeRef || new (_semanticsEntities().InferenceTypeSchema)(location, type), isOptional));
+    }
+    return paramSchemas;
+  }
+
+  /**
+   * Create schema for object literal type
+   */
+  createObjectSchema(node, location, displayString) {
+    const objMatch = displayString.match(/{([^}]+)}/);
+    if (!objMatch) {
+      return new (_semanticsEntities().InferenceTypeSchema)(location, 'object');
+    }
+    const objContent = objMatch[1];
+    const properties = objContent.split(';').map(prop => prop.trim()).filter(Boolean).map(prop => new (_semanticsEntities().InferenceTypeSchema)(location, prop));
+    return new (_semanticsEntities().ArrayLiteralExpressionSchema)(properties, location);
+  }
+
+  /**
+   * Create schema for Promise type, attempting to get type reference for the contained type
+   */
+  async createPromiseSchema(node, location, innerType) {
+    const typeRef = await this.getTypeRef(innerType, this.getIdentifierKeyForNode(node), location);
+    return typeRef || new (_semanticsEntities().InferenceTypeSchema)(location, innerType);
+  }
+
+  // the reason for this check is to avoid infinite loop when calling `this.jump` with the same file+location
+  isDefInSameLocation(node, definition) {
+    if (definition.file !== node.getSourceFile().fileName) {
+      return false;
+    }
+    const loc = this.getLocation(node);
+    return loc.line === definition.start.line && loc.character === definition.start.offset;
+  }
+
+  /**
+   * resolve a type by a node and its identifier.
+   */
+  async resolveType(node, typeStr) {
+    const location = this.getLocation(node);
+
+    // check if internal ref with typeInfo
+    const internalRef = await this.getTypeRef(typeStr, this.getIdentifierKeyForNode(node), location);
+    if (internalRef) return internalRef;
+
+    // if a node has "type" prop, it has the type data of the node. this normally happens when the code has the type
+    // explicitly, e.g. `const str: string` vs implicitly `const str = 'some-string'`, which the node won't have "type"
+    if (node.type && _typescript().default.isTypeNode(node.type)) {
+      return this.computeSchema(node.type);
+    }
+    const definition = await this.getDefinition(node);
+    if (!definition) {
+      return this.unknownExactType(node, location, typeStr);
+    }
+    if (this.isDefInSameLocation(node, definition)) {
+      return this.unknownExactType(node, location, typeStr);
+    }
+    const definitionNode = await this.definition(definition);
+    if (!definitionNode) {
+      return this.unknownExactType(node, location, typeStr);
+    }
+    const definitionNodeName = definitionNode?.getText();
+
+    // check if internal ref with definition info
+    const definitionInternalRef = await this.getTypeRef(definitionNodeName, this.getIdentifierKeyForNode(definitionNode), location);
+    if (definitionInternalRef) return definitionInternalRef;
+    const transformer = this.extractor.getTransformer(definitionNode, this);
+    if (transformer === undefined) {
+      const file = this.findFileInComponent(definition.file);
+      if (!file) return this.getTypeRefForExternalPath(typeStr, definition.file, location);
+      return this.unknownExactType(node, location, typeStr);
+    }
+    const schemaNode = await this.visit(definitionNode);
+    if (!schemaNode) {
+      return this.unknownExactType(node, location, typeStr);
+    }
+    const apiTransformer = this.extractor.getAPITransformer(schemaNode);
+    let transformedApi = apiTransformer ? await apiTransformer.transform(schemaNode, this) : schemaNode;
+    if (!transformedApi) {
+      transformedApi = new (_semanticsEntities().IgnoredSchema)(schemaNode);
+    }
+    return transformedApi;
+  }
+  getCompIdByPkgName(pkgName) {
+    return this.componentDeps.find(dep => dep.packageName === pkgName)?.componentId;
+  }
+  async getTypeRef(typeStr, filePath, location) {
+    const nodeIdentifierKey = this.getIdentifierKey(filePath);
+    const mainFileIdentifierKey = this.mainFileIdentifierKey;
+    const nodeIdentifierList = this.identifiers.get(nodeIdentifierKey);
+    const mainIdentifierList = this.identifiers.get(mainFileIdentifierKey);
+    const nodeIdentifier = new (_identifier().Identifier)(typeStr, nodeIdentifierKey);
+    const mainIdentifier = new (_identifier().Identifier)(typeStr, mainFileIdentifierKey);
+    const parsedNodeIdentifier = nodeIdentifierList?.find(nodeIdentifier);
+    const parsedMainIdentifier = mainIdentifierList?.find(mainIdentifier);
+    const isExportedFromMain = parsedMainIdentifier && _exportIdentifier().ExportIdentifier.isExportIdentifier(parsedMainIdentifier);
+    if (!parsedNodeIdentifier) return undefined;
+    const internalRef = !isExportedFromMain;
+    if (internalRef) {
+      this.setInternalIdentifiers(parsedNodeIdentifier.normalizedPath, new (_identifierList().IdentifierList)([parsedNodeIdentifier]));
+    }
+    return this.resolveTypeRef(parsedNodeIdentifier, location, isExportedFromMain);
+  }
+  async resolveTypeRef(identifier, location, isExportedFromMain) {
+    const sourceFilePath = identifier.sourceFilePath;
+    if (!sourceFilePath || isExportedFromMain && (0, _legacy().isRelativeImport)(sourceFilePath)) {
+      return new (_semanticsEntities().TypeRefSchema)(location, identifier.id, undefined, undefined, !isExportedFromMain ? this.getPathRelativeToComponent(identifier.filePath) : undefined);
+    }
+    if (!(0, _legacy().isRelativeImport)(sourceFilePath)) {
+      const pkgName = this.parsePackageNameFromPath(sourceFilePath);
+      const compIdByPkg = this.getCompIdByPkgName(pkgName);
+      const compIdByPath = await this.extractor.getComponentIDByPath(sourceFilePath);
+      if (compIdByPath) {
+        return new (_semanticsEntities().TypeRefSchema)(location, identifier.id, compIdByPath);
+      }
+      if (compIdByPkg) {
+        return new (_semanticsEntities().TypeRefSchema)(location, identifier.id, compIdByPkg);
+      }
+
+      // package without comp id
+      return new (_semanticsEntities().TypeRefSchema)(location, identifier.id, undefined, pkgName);
+    }
+    const relativeDir = identifier.filePath.substring(0, identifier.filePath.lastIndexOf('/'));
+    const absFilePath = (0, _path().resolve)(this.componentRootPath, relativeDir, sourceFilePath);
+    const compFilePath = this.findFileInComponent(absFilePath);
+    if (!compFilePath) {
+      // @todo handle this better
+      throw new Error(`cannot find file in component \n source file path ${sourceFilePath}\n
+        identifier file path ${identifier.filePath}\nrelative dir ${relativeDir}\n
+        absFilePath ${absFilePath}`);
+      return new (_semanticsEntities().TypeRefSchema)(location, identifier.id);
+    }
+    const idKey = this.getIdentifierKey(compFilePath?.path);
+
+    // if re exported from a file, recurse until definition
+    const exportedIdentifier = (this.identifiers.get(idKey)?.identifiers || []).find(i => i.id === identifier.id);
+    if (exportedIdentifier) {
+      return this.resolveTypeRef(exportedIdentifier, location, isExportedFromMain);
+    }
+    return new (_semanticsEntities().TypeRefSchema)(location, identifier.id);
+  }
+  async getTypeRefForExternalNode(node) {
+    const info = await this.getQuickInfo(node);
+    const typeStr = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
+    const location = this.getLocation(node);
+    const filePath = this.getPath(node);
+    return this.getTypeRefForExternalPath(typeStr, filePath, location);
+  }
+  async getTypeRefForExternalPath(typeStr, filePath, location) {
+    const compIdByPath = await this.extractor.getComponentIDByPath(filePath);
+    if (compIdByPath) {
+      return new (_semanticsEntities().TypeRefSchema)(location, typeStr, compIdByPath);
+    }
+    const pkgName = this.parsePackageNameFromPath(filePath);
+    const compIdByPkg = this.getCompIdByPkgName(pkgName);
+    if (compIdByPkg) {
+      return new (_semanticsEntities().TypeRefSchema)(location, typeStr, compIdByPkg);
+    }
+    return new (_semanticsEntities().TypeRefSchema)(location, typeStr, undefined, pkgName);
+  }
+  async jsDocToDocSchema(node) {
+    if (!(0, _tsutils().canHaveJsDoc)(node)) {
+      return undefined;
+    }
+    const jsDocs = (0, _tsutils().getJsDoc)(node);
+    if (!jsDocs.length) {
+      return undefined;
+    }
+    // not sure how common it is to have multiple JSDocs. never seen it before.
+    // regardless, in typescript implementation of methods like `getJSDocDeprecatedTag()`, they use the first one. (`getFirstJSDocTag()`)
+    const jsDoc = jsDocs[0];
+    const location = this.getLocation(jsDoc);
+    // Extract link comments and filter them out from the main comment
+    const linkComments = typeof jsDoc.comment !== 'string' ? jsDoc.comment?.filter(c => c.kind === _typescript().default.SyntaxKind.JSDocLink) ?? [] : [];
+    const linkTags = linkComments.map(linkComment => {
+      const tagName = 'link';
+      const tagText = `${linkComment.name?.getText() ?? ''}${linkComment.text ?? ''}`;
+      const tagLocation = this.getLocation(linkComment);
+      return new (_semanticsEntities().TagSchema)(tagLocation, tagName, tagText);
+    });
+    const commentsWithoutLink = typeof jsDoc.comment !== 'string' ? jsDoc.comment?.filter(c => c.kind !== _typescript().default.SyntaxKind.JSDocLink) ?? '' : jsDoc.comment;
+    const comment = (0, _typescript().getTextOfJSDocComment)(commentsWithoutLink);
+    const tags = (jsDoc.tags ? await (0, _pMapSeries().default)(jsDoc.tags, tag => (0, _jsdocToDocSchema().tagParser)(tag, this, this.formatter)) : []).concat(linkTags);
+    return new (_semanticsEntities().DocSchema)(location, jsDoc.getText(), comment, tags);
+  }
+}
+exports.SchemaExtractorContext = SchemaExtractorContext;
+
+//# sourceMappingURL=schema-extractor-context.js.map