@teambit/typescript 1.0.551 → 1.0.552

package/dist/identifier.d.ts

@@ -3,7 +3,9 @@ export declare class Identifier {
     readonly filePath: string;
     readonly aliasId?: string | undefined;
     readonly sourceFilePath?: string | undefined;
+    readonly normalizedPath: string;
     constructor(id: string, filePath: string, aliasId?: string | undefined, sourceFilePath?: string | undefined);
+    private static computeNormalizedPath;
     isEqual(identifier: Identifier): boolean;
     static isDefault(identifier: Identifier): boolean;
 }

package/dist/identifier.js

@@ -4,21 +4,36 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.Identifier = void 0;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+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); }
 class Identifier {
   constructor(id, filePath, aliasId, sourceFilePath) {
     this.id = id;
     this.filePath = filePath;
     this.aliasId = aliasId;
     this.sourceFilePath = sourceFilePath;
+    _defineProperty(this, "normalizedPath", void 0);
+    this.normalizedPath = Identifier.computeNormalizedPath(filePath, sourceFilePath);
   }
-  isEqual(identifier) {
-    if (this.filePath !== identifier.filePath) return false;
-    if (Identifier.isDefault(identifier) && Identifier.isDefault(this)) {
-      return true;
-    }
-    if (Identifier.isDefault(identifier) || Identifier.isDefault(this)) {
-      return false;
+  static computeNormalizedPath(filePath, sourceFilePath) {
+    let effectivePath = filePath;
+    if (sourceFilePath) {
+      effectivePath = (0, _path().isAbsolute)(sourceFilePath) ? sourceFilePath : (0, _path().resolve)((0, _path().dirname)(filePath), sourceFilePath);
     }
+    return (0, _path().normalize)(effectivePath).replace(/\\/g, '/');
+  }
+  isEqual(identifier) {
+    if (this.filePath !== identifier.filePath && this.normalizedPath !== identifier.normalizedPath) return false;
+    if (Identifier.isDefault(identifier) && Identifier.isDefault(this)) return true;
+    if (Identifier.isDefault(identifier) || Identifier.isDefault(this)) return false;
     return this.id === identifier.id;
   }
   static isDefault(identifier) {

package/dist/identifier.js.map

@@ -1 +1 @@
-{"version":3,"names":["Identifier","constructor","id","filePath","aliasId","sourceFilePath","isEqual","identifier","isDefault","exports"],"sources":["identifier.ts"],"sourcesContent":["export class Identifier {\n  constructor(\n    readonly id: string,\n    readonly filePath: string,\n    readonly aliasId?: string,\n    readonly sourceFilePath?: string\n  ) {}\n\n  isEqual(identifier: Identifier): boolean {\n    if (this.filePath !== identifier.filePath) return false;\n    if (Identifier.isDefault(identifier) && Identifier.isDefault(this)) {\n      return true;\n    }\n    if (Identifier.isDefault(identifier) || Identifier.isDefault(this)) {\n      return false;\n    }\n    return this.id === identifier.id;\n  }\n\n  static isDefault(identifier: Identifier) {\n    return identifier.id === 'default';\n  }\n}\n"],"mappings":";;;;;;AAAO,MAAMA,UAAU,CAAC;EACtBC,WAAWA,CACAC,EAAU,EACVC,QAAgB,EAChBC,OAAgB,EAChBC,cAAuB,EAChC;IAAA,KAJSH,EAAU,GAAVA,EAAU;IAAA,KACVC,QAAgB,GAAhBA,QAAgB;IAAA,KAChBC,OAAgB,GAAhBA,OAAgB;IAAA,KAChBC,cAAuB,GAAvBA,cAAuB;EAC/B;EAEHC,OAAOA,CAACC,UAAsB,EAAW;IACvC,IAAI,IAAI,CAACJ,QAAQ,KAAKI,UAAU,CAACJ,QAAQ,EAAE,OAAO,KAAK;IACvD,IAAIH,UAAU,CAACQ,SAAS,CAACD,UAAU,CAAC,IAAIP,UAAU,CAACQ,SAAS,CAAC,IAAI,CAAC,EAAE;MAClE,OAAO,IAAI;IACb;IACA,IAAIR,UAAU,CAACQ,SAAS,CAACD,UAAU,CAAC,IAAIP,UAAU,CAACQ,SAAS,CAAC,IAAI,CAAC,EAAE;MAClE,OAAO,KAAK;IACd;IACA,OAAO,IAAI,CAACN,EAAE,KAAKK,UAAU,CAACL,EAAE;EAClC;EAEA,OAAOM,SAASA,CAACD,UAAsB,EAAE;IACvC,OAAOA,UAAU,CAACL,EAAE,KAAK,SAAS;EACpC;AACF;AAACO,OAAA,CAAAT,UAAA,GAAAA,UAAA","ignoreList":[]}
+{"version":3,"names":["_path","data","require","_defineProperty","e","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","Identifier","constructor","id","filePath","aliasId","sourceFilePath","normalizedPath","computeNormalizedPath","effectivePath","isAbsolute","resolve","dirname","normalize","replace","isEqual","identifier","isDefault","exports"],"sources":["identifier.ts"],"sourcesContent":["import { isAbsolute, resolve, dirname, normalize } from 'path';\nexport class Identifier {\n  public readonly normalizedPath: string;\n\n  constructor(\n    readonly id: string,\n    readonly filePath: string,\n    readonly aliasId?: string,\n    readonly sourceFilePath?: string\n  ) {\n    this.normalizedPath = Identifier.computeNormalizedPath(filePath, sourceFilePath);\n  }\n\n  private static computeNormalizedPath(filePath: string, sourceFilePath?: string): string {\n    let effectivePath = filePath;\n    if (sourceFilePath) {\n      effectivePath = isAbsolute(sourceFilePath)\n        ? sourceFilePath\n        : resolve(dirname(filePath), sourceFilePath);\n    }\n    return normalize(effectivePath).replace(/\\\\/g, '/');\n  }\n\n  isEqual(identifier: Identifier): boolean {\n    if (this.filePath !== identifier.filePath && this.normalizedPath !== identifier.normalizedPath) return false;\n    if (Identifier.isDefault(identifier) && Identifier.isDefault(this)) return true;\n    if (Identifier.isDefault(identifier) || Identifier.isDefault(this)) return false;\n    return this.id === identifier.id;\n  }\n\n  static isDefault(identifier: Identifier) {\n    return identifier.id === 'default';\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,MAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,KAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA+D,SAAAE,gBAAAC,CAAA,EAAAC,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAE,cAAA,CAAAF,CAAA,MAAAD,CAAA,GAAAI,MAAA,CAAAC,cAAA,CAAAL,CAAA,EAAAC,CAAA,IAAAK,KAAA,EAAAJ,CAAA,EAAAK,UAAA,MAAAC,YAAA,MAAAC,QAAA,UAAAT,CAAA,CAAAC,CAAA,IAAAC,CAAA,EAAAF,CAAA;AAAA,SAAAG,eAAAD,CAAA,QAAAQ,CAAA,GAAAC,YAAA,CAAAT,CAAA,uCAAAQ,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAT,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAF,CAAA,GAAAE,CAAA,CAAAU,MAAA,CAAAC,WAAA,kBAAAb,CAAA,QAAAU,CAAA,GAAAV,CAAA,CAAAc,IAAA,CAAAZ,CAAA,EAAAD,CAAA,uCAAAS,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAAd,CAAA,GAAAe,MAAA,GAAAC,MAAA,EAAAf,CAAA;AACxD,MAAMgB,UAAU,CAAC;EAGtBC,WAAWA,CACAC,EAAU,EACVC,QAAgB,EAChBC,OAAgB,EAChBC,cAAuB,EAChC;IAAA,KAJSH,EAAU,GAAVA,EAAU;IAAA,KACVC,QAAgB,GAAhBA,QAAgB;IAAA,KAChBC,OAAgB,GAAhBA,OAAgB;IAAA,KAChBC,cAAuB,GAAvBA,cAAuB;IAAAxB,eAAA;IAEhC,IAAI,CAACyB,cAAc,GAAGN,UAAU,CAACO,qBAAqB,CAACJ,QAAQ,EAAEE,cAAc,CAAC;EAClF;EAEA,OAAeE,qBAAqBA,CAACJ,QAAgB,EAAEE,cAAuB,EAAU;IACtF,IAAIG,aAAa,GAAGL,QAAQ;IAC5B,IAAIE,cAAc,EAAE;MAClBG,aAAa,GAAG,IAAAC,kBAAU,EAACJ,cAAc,CAAC,GACtCA,cAAc,GACd,IAAAK,eAAO,EAAC,IAAAC,eAAO,EAACR,QAAQ,CAAC,EAAEE,cAAc,CAAC;IAChD;IACA,OAAO,IAAAO,iBAAS,EAACJ,aAAa,CAAC,CAACK,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;EACrD;EAEAC,OAAOA,CAACC,UAAsB,EAAW;IACvC,IAAI,IAAI,CAACZ,QAAQ,KAAKY,UAAU,CAACZ,QAAQ,IAAI,IAAI,CAACG,cAAc,KAAKS,UAAU,CAACT,cAAc,EAAE,OAAO,KAAK;IAC5G,IAAIN,UAAU,CAACgB,SAAS,CAACD,UAAU,CAAC,IAAIf,UAAU,CAACgB,SAAS,CAAC,IAAI,CAAC,EAAE,OAAO,IAAI;IAC/E,IAAIhB,UAAU,CAACgB,SAAS,CAACD,UAAU,CAAC,IAAIf,UAAU,CAACgB,SAAS,CAAC,IAAI,CAAC,EAAE,OAAO,KAAK;IAChF,OAAO,IAAI,CAACd,EAAE,KAAKa,UAAU,CAACb,EAAE;EAClC;EAEA,OAAOc,SAASA,CAACD,UAAsB,EAAE;IACvC,OAAOA,UAAU,CAACb,EAAE,KAAK,SAAS;EACpC;AACF;AAACe,OAAA,CAAAjB,UAAA,GAAAA,UAAA","ignoreList":[]}

package/dist/{preview-1740194344610.js → preview-1740280818215.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@1.0.551/dist/typescript.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@1.0.551/dist/typescript.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@1.0.552/dist/typescript.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@1.0.552/dist/typescript.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/schema-extractor-context.d.ts

@@ -103,14 +103,56 @@ export declare class SchemaExtractorContext {
      * "definition" but it's not clear when/why).
      */
     getDefinition(node: Node): Promise<ts.server.protocol.FileSpanWithContext | undefined>;
+    /**
+     * 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
+     */
     private unknownExactType;
+    /**
+     * Check if type is an array type (either T[] or Array<T>)
+     */
+    private isArrayType;
+    /**
+     * Extract base type from array type
+     */
+    private getArrayBaseType;
+    /**
+     * Extract return type from method signature
+     */
+    private extractMethodReturnType;
+    /**
+     * Extract content from generic type
+     */
+    private extractGenericType;
+    /**
+     * Create schema for method return type, attempting to get type reference
+     */
+    private createMethodReturnSchema;
+    /**
+     * Create schema for function type, handling params and return type
+     */
+    private createFunctionSchema;
+    /**
+     * Create parameters for function schema, attempting to get type references for param types
+     */
+    private createFunctionParameters;
+    /**
+     * Create schema for object literal type
+     */
+    private createObjectSchema;
+    /**
+     * Create schema for Promise type, attempting to get type reference for the contained type
+     */
+    private createPromiseSchema;
     private isDefInSameLocation;
     /**
      * resolve a type by a node and its identifier.
      */
     resolveType(node: Node & {
         type?: TypeNode;
-    }, typeStr: string, isTypeStrFromQuickInfo?: boolean): Promise<SchemaNode>;
+    }, typeStr: string): Promise<SchemaNode>;
     private getCompIdByPkgName;
     getTypeRef(typeStr: string, filePath: string, location: Location): Promise<TypeRefSchema | undefined>;
     resolveTypeRef(identifier: Identifier, location: Location, isExportedFromMain?: boolean): Promise<TypeRefSchema>;

package/dist/schema-extractor-context.js

@@ -420,14 +420,165 @@ class SchemaExtractorContext {
     return headDefinition;
   }
 
-  // when we can't figure out the component/package/type of this node, we'll use the typeStr as the type.
-  async unknownExactType(node, location, typeStr = 'any', isTypeStrFromQuickInfo = true) {
-    if (isTypeStrFromQuickInfo) {
+  /**
+   * 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');
     }
-    const info = await this.getQuickInfo(node);
-    const type = (0, _parseTypeFromQuickInfo().parseTypeFromQuickInfo)(info);
-    return new (_semanticsEntities().InferenceTypeSchema)(location, type, typeStr);
+  }
+
+  /**
+   * 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
@@ -442,7 +593,7 @@ class SchemaExtractorContext {
   /**
    * resolve a type by a node and its identifier.
    */
-  async resolveType(node, typeStr, isTypeStrFromQuickInfo = true) {
+  async resolveType(node, typeStr) {
     const location = this.getLocation(node);
 
     // check if internal ref with typeInfo
@@ -456,14 +607,14 @@ class SchemaExtractorContext {
     }
     const definition = await this.getDefinition(node);
     if (!definition) {
-      return this.unknownExactType(node, location, typeStr, isTypeStrFromQuickInfo);
+      return this.unknownExactType(node, location, typeStr);
     }
     if (this.isDefInSameLocation(node, definition)) {
-      return this.unknownExactType(node, location, typeStr, isTypeStrFromQuickInfo);
+      return this.unknownExactType(node, location, typeStr);
     }
     const definitionNode = await this.definition(definition);
     if (!definitionNode) {
-      return this.unknownExactType(node, location, typeStr, isTypeStrFromQuickInfo);
+      return this.unknownExactType(node, location, typeStr);
     }
     const definitionNodeName = definitionNode?.getText();
 
@@ -474,11 +625,11 @@ class SchemaExtractorContext {
     if (transformer === undefined) {
       const file = this.findFileInComponent(definition.file);
       if (!file) return this.getTypeRefForExternalPath(typeStr, definition.file, location);
-      return this.unknownExactType(node, location, typeStr, isTypeStrFromQuickInfo);
+      return this.unknownExactType(node, location, typeStr);
     }
     const schemaNode = await this.visit(definitionNode);
     if (!schemaNode) {
-      return this.unknownExactType(node, location, typeStr, isTypeStrFromQuickInfo);
+      return this.unknownExactType(node, location, typeStr);
     }
     const apiTransformer = this.extractor.getAPITransformer(schemaNode);
     let transformedApi = apiTransformer ? await apiTransformer.transform(schemaNode, this) : schemaNode;
@@ -503,7 +654,7 @@ class SchemaExtractorContext {
     if (!parsedNodeIdentifier) return undefined;
     const internalRef = !isExportedFromMain;
     if (internalRef) {
-      this.setInternalIdentifiers(filePath, new (_identifierList().IdentifierList)([parsedNodeIdentifier]));
+      this.setInternalIdentifiers(parsedNodeIdentifier.normalizedPath, new (_identifierList().IdentifierList)([parsedNodeIdentifier]));
     }
     return this.resolveTypeRef(parsedNodeIdentifier, location, isExportedFromMain);
   }