@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/dist/index.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  TypescriptConfigMutator: true,
+  TypeScriptExtractor: true,
+  TypescriptCompiler: true,
+  TypescriptAspect: true,
+  SchemaExtractorContext: true
+};
+Object.defineProperty(exports, "SchemaExtractorContext", {
+  enumerable: true,
+  get: function () {
+    return _schemaExtractorContext().SchemaExtractorContext;
+  }
+});
+Object.defineProperty(exports, "TypeScriptExtractor", {
+  enumerable: true,
+  get: function () {
+    return _typescript().TypeScriptExtractor;
+  }
+});
+Object.defineProperty(exports, "TypescriptAspect", {
+  enumerable: true,
+  get: function () {
+    return _typescript3().TypescriptAspect;
+  }
+});
+Object.defineProperty(exports, "TypescriptCompiler", {
+  enumerable: true,
+  get: function () {
+    return _typescript2().TypescriptCompiler;
+  }
+});
+Object.defineProperty(exports, "TypescriptConfigMutator", {
+  enumerable: true,
+  get: function () {
+    return _typescriptModules().TypescriptConfigMutator;
+  }
+});
+function _typescriptModules() {
+  const data = require("@teambit/typescript.modules.ts-config-mutator");
+  _typescriptModules = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = require("./typescript.extractor");
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript2() {
+  const data = require("@teambit/typescript.typescript-compiler");
+  _typescript2 = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript3() {
+  const data = require("./typescript.aspect");
+  _typescript3 = function () {
+    return data;
+  };
+  return data;
+}
+var _sourceFileTransformers = require("./sourceFileTransformers");
+Object.keys(_sourceFileTransformers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _sourceFileTransformers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _sourceFileTransformers[key];
+    }
+  });
+});
+function _schemaExtractorContext() {
+  const data = require("./schema-extractor-context");
+  _schemaExtractorContext = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_typescriptModules","data","require","_typescript","_typescript2","_typescript3","_sourceFileTransformers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_schemaExtractorContext"],"sources":["index.ts"],"sourcesContent":["export { TypescriptConfigMutator } from '@teambit/typescript.modules.ts-config-mutator';\nexport { TypeScriptExtractor } from './typescript.extractor';\nexport { TypescriptCompiler } from '@teambit/typescript.typescript-compiler';\nexport type {\n  TypescriptMain,\n  TsConfigTransformer,\n  SchemaTransformerSlot,\n  APITransformerSlot,\n} from './typescript.main.runtime';\nexport type { TypeScriptCompilerOptions, TsCompilerOptionsWithoutTsConfig } from './compiler-options';\nexport { TypescriptAspect } from './typescript.aspect';\nexport * from './sourceFileTransformers';\nexport type { SchemaNodeTransformer, SchemaTransformer } from './schema-transformer';\nexport { SchemaExtractorContext } from './schema-extractor-context';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,mBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,kBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,aAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,YAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAQA,SAAAI,aAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,YAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,IAAAK,uBAAA,GAAAJ,OAAA;AAAAK,MAAA,CAAAC,IAAA,CAAAF,uBAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,uBAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,uBAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AAEA,SAAAS,wBAAA;EAAA,MAAAlB,IAAA,GAAAC,OAAA;EAAAiB,uBAAA,YAAAA,CAAA;IAAA,OAAAlB,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/preview-1760469561956.js

@@ -0,0 +1,7 @@
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@004aea01bc027e428dfd0f6583f49a1b8286bdd0/dist/typescript.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.typescript_typescript@004aea01bc027e428dfd0f6583f49a1b8286bdd0/dist/typescript.docs.mdx';
+
+export const compositions = [compositions_0];
+export const overview = [overview_0];
+
+export const compositions_metadata = {"compositions":[{"displayName":"Logo","identifier":"Logo"}]};

package/dist/remove-types-task.d.ts

@@ -0,0 +1,12 @@
+import type { BuildContext, BuildTask, BuiltTaskResult } from '@teambit/builder';
+export declare class RemoveTypesTask implements BuildTask {
+    readonly aspectId: string;
+    readonly name = "RemoveTypesProp";
+    readonly description = "remove the types prop from package.json";
+    execute(context: BuildContext): Promise<BuiltTaskResult>;
+    /**
+     * the types['index.ts'] is needed only during the build to avoid errors when tsc finds the
+     * same type once in the d.ts and once in the ts file.
+     */
+    private removeTypesFromPkgJson;
+}

package/dist/remove-types-task.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RemoveTypesTask = void 0;
+function _component() {
+  const data = require("@teambit/component.sources");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = require("./typescript.aspect");
+  _typescript = 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 RemoveTypesTask {
+  constructor() {
+    _defineProperty(this, "aspectId", _typescript().TypescriptAspect.id);
+    _defineProperty(this, "name", 'RemoveTypesProp');
+    _defineProperty(this, "description", 'remove the types prop from package.json');
+  }
+  async execute(context) {
+    await this.removeTypesFromPkgJson(context);
+    const result = {
+      componentsResults: []
+    };
+    return result;
+  }
+
+  /**
+   * the types['index.ts'] is needed only during the build to avoid errors when tsc finds the
+   * same type once in the d.ts and once in the ts file.
+   */
+  async removeTypesFromPkgJson(context) {
+    if (context.env?.getPackageJsonProps && typeof context.env.getPackageJsonProps === 'function') {
+      const propsFromEnv = context.env.getPackageJsonProps();
+      // in case the env has its own "types" prop and it's not the "types" automatically added to the source in order
+      // to to avoid build error, then keep it.
+      if (propsFromEnv.types !== '{main}.ts') {
+        return;
+      }
+    }
+    await Promise.all(context.capsuleNetwork.seedersCapsules.map(async capsule => {
+      const packageJson = _component().PackageJsonFile.loadFromCapsuleSync(capsule.path);
+      // the reason for `packageJson.packageJsonObject.main` is that .d.ts components don't have a main file and they
+      // do need the types prop
+      if (packageJson.packageJsonObject.types && packageJson.packageJsonObject.main) {
+        delete packageJson.packageJsonObject.types;
+        await packageJson.write();
+      }
+    }));
+  }
+}
+exports.RemoveTypesTask = RemoveTypesTask;
+
+//# sourceMappingURL=remove-types-task.js.map

package/dist/remove-types-task.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_component","data","require","_typescript","_defineProperty","e","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","RemoveTypesTask","constructor","TypescriptAspect","id","execute","context","removeTypesFromPkgJson","result","componentsResults","env","getPackageJsonProps","propsFromEnv","types","Promise","all","capsuleNetwork","seedersCapsules","map","capsule","packageJson","PackageJsonFile","loadFromCapsuleSync","path","packageJsonObject","main","write","exports"],"sources":["remove-types-task.ts"],"sourcesContent":["import { PackageJsonFile } from '@teambit/component.sources';\nimport type { BuildContext, BuildTask, BuiltTaskResult } from '@teambit/builder';\nimport { TypescriptAspect } from './typescript.aspect';\n\nexport class RemoveTypesTask implements BuildTask {\n  readonly aspectId = TypescriptAspect.id;\n  readonly name = 'RemoveTypesProp';\n  readonly description = 'remove the types prop from package.json';\n  async execute(context: BuildContext): Promise<BuiltTaskResult> {\n    await this.removeTypesFromPkgJson(context);\n\n    const result = {\n      componentsResults: [],\n    };\n\n    return result;\n  }\n\n  /**\n   * the types['index.ts'] is needed only during the build to avoid errors when tsc finds the\n   * same type once in the d.ts and once in the ts file.\n   */\n  private async removeTypesFromPkgJson(context: BuildContext) {\n    if (context.env?.getPackageJsonProps && typeof context.env.getPackageJsonProps === 'function') {\n      const propsFromEnv = context.env.getPackageJsonProps();\n      // in case the env has its own \"types\" prop and it's not the \"types\" automatically added to the source in order\n      // to to avoid build error, then keep it.\n      if (propsFromEnv.types !== '{main}.ts') {\n        return;\n      }\n    }\n    await Promise.all(\n      context.capsuleNetwork.seedersCapsules.map(async (capsule) => {\n        const packageJson = PackageJsonFile.loadFromCapsuleSync(capsule.path);\n        // the reason for `packageJson.packageJsonObject.main` is that .d.ts components don't have a main file and they\n        // do need the types prop\n        if (packageJson.packageJsonObject.types && packageJson.packageJsonObject.main) {\n          delete packageJson.packageJsonObject.types;\n          await packageJson.write();\n        }\n      })\n    );\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,WAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,UAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAE,YAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,WAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAuD,SAAAG,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;AAEhD,MAAMgB,eAAe,CAAsB;EAAAC,YAAA;IAAApB,eAAA,mBAC5BqB,8BAAgB,CAACC,EAAE;IAAAtB,eAAA,eACvB,iBAAiB;IAAAA,eAAA,sBACV,yCAAyC;EAAA;EAChE,MAAMuB,OAAOA,CAACC,OAAqB,EAA4B;IAC7D,MAAM,IAAI,CAACC,sBAAsB,CAACD,OAAO,CAAC;IAE1C,MAAME,MAAM,GAAG;MACbC,iBAAiB,EAAE;IACrB,CAAC;IAED,OAAOD,MAAM;EACf;;EAEA;AACF;AACA;AACA;EACE,MAAcD,sBAAsBA,CAACD,OAAqB,EAAE;IAC1D,IAAIA,OAAO,CAACI,GAAG,EAAEC,mBAAmB,IAAI,OAAOL,OAAO,CAACI,GAAG,CAACC,mBAAmB,KAAK,UAAU,EAAE;MAC7F,MAAMC,YAAY,GAAGN,OAAO,CAACI,GAAG,CAACC,mBAAmB,CAAC,CAAC;MACtD;MACA;MACA,IAAIC,YAAY,CAACC,KAAK,KAAK,WAAW,EAAE;QACtC;MACF;IACF;IACA,MAAMC,OAAO,CAACC,GAAG,CACfT,OAAO,CAACU,cAAc,CAACC,eAAe,CAACC,GAAG,CAAC,MAAOC,OAAO,IAAK;MAC5D,MAAMC,WAAW,GAAGC,4BAAe,CAACC,mBAAmB,CAACH,OAAO,CAACI,IAAI,CAAC;MACrE;MACA;MACA,IAAIH,WAAW,CAACI,iBAAiB,CAACX,KAAK,IAAIO,WAAW,CAACI,iBAAiB,CAACC,IAAI,EAAE;QAC7E,OAAOL,WAAW,CAACI,iBAAiB,CAACX,KAAK;QAC1C,MAAMO,WAAW,CAACM,KAAK,CAAC,CAAC;MAC3B;IACF,CAAC,CACH,CAAC;EACH;AACF;AAACC,OAAA,CAAA1B,eAAA,GAAAA,eAAA","ignoreList":[]}

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

@@ -0,0 +1,164 @@
+import type { TsserverClient } from '@teambit/ts-server';
+import type { ExportAssignment, ExportDeclaration, Node, TypeNode } from 'typescript';
+import ts from 'typescript';
+import type protocol from 'typescript/lib/protocol';
+import type { Component } from '@teambit/component';
+import type { SchemaNode, Location } from '@teambit/semantics.entities.semantic-schema';
+import { TypeRefSchema, DocSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { ComponentDependency } from '@teambit/dependency-resolver';
+import type { Formatter } from '@teambit/formatter';
+import type { TypeScriptExtractor } from './typescript.extractor';
+import { IdentifierList } from './identifier-list';
+import { Identifier } from './identifier';
+import { ExportIdentifier } from './export-identifier';
+export declare class SchemaExtractorContext {
+    readonly tsserver: TsserverClient;
+    readonly component: Component;
+    readonly extractor: TypeScriptExtractor;
+    readonly componentDeps: ComponentDependency[];
+    readonly componentRootPath: string;
+    readonly hostRootPath: string;
+    readonly formatter?: Formatter | undefined;
+    /**
+     * list of all declared identifiers (exported and internal) by filename
+     */
+    private _identifiers;
+    private _internalIdentifiers;
+    /**
+     * computed nodes by filename and (position (line:character))
+     */
+    private _computed;
+    get mainFile(): string;
+    get identifiers(): Map<string, IdentifierList>;
+    get internalIdentifiers(): Map<string, IdentifierList>;
+    get computed(): Map<string, SchemaNode>;
+    get mainFileIdentifierKey(): string;
+    get mainModuleIdentifiers(): IdentifierList | undefined;
+    constructor(tsserver: TsserverClient, component: Component, extractor: TypeScriptExtractor, componentDeps: ComponentDependency[], componentRootPath: string, hostRootPath: string, formatter?: Formatter | undefined);
+    getComputedNodeKey({ filePath, line, character }: Location, schema: string): string;
+    getIdentifierKeyForNode(node: Node): string;
+    getIdentifierKey(filePath: string): string;
+    setComputed(node: SchemaNode): void;
+    setIdentifiers(filePath: string, identifiers: IdentifierList): void;
+    setInternalIdentifiers(filePath: string, identifiers: IdentifierList): void;
+    findComputedSchemaByName(name: string): SchemaNode[];
+    computeSchema(node: Node): Promise<SchemaNode>;
+    transformSchemaNode(schema: SchemaNode): Promise<SchemaNode>;
+    /**
+     * returns the location of a node in a source file.
+     */
+    getLocation(node: Node, targetSourceFile?: ts.SourceFile, absolutePath?: boolean): Location;
+    getLocationAsString(node: Node): string;
+    getPathRelativeToComponent(filePath: string): string;
+    /**
+     * returns a signature for a node.
+     */
+    getSignature(node: Node): Promise<ts.server.protocol.SignatureHelpResponse | undefined>;
+    /**
+     * get the position for the tsserver.
+     */
+    getPosition(sourceFile: ts.SourceFile, line: number, offset: number): number;
+    /**
+     * get the path for a source file.
+     */
+    getPath(node: Node): string;
+    getQuickInfo(node: Node): Promise<ts.server.protocol.QuickInfoResponse | undefined>;
+    getQuickInfoDisplayString(node: Node): Promise<string>;
+    /**
+     * returns the type definition for a type.
+     */
+    typeDefinition(node: Node): Promise<ts.server.protocol.TypeDefinitionResponse | undefined>;
+    visitTypeDefinition(): void;
+    private getPathWithoutExtension;
+    private isIndexFile;
+    findFileInComponent(filePath: string): import("@teambit/component.sources").AbstractVinyl | undefined;
+    private parsePackageNameFromPath;
+    /**
+     * return the file if part of the component.
+     * otherwise, a reference to the target package and the type name.
+     */
+    getSourceFileInsideComponent(filePath: string): ts.SourceFile | undefined;
+    getSourceFileFromNode(node: Node): Promise<ts.SourceFile | undefined>;
+    getFilePathByNode(node: Node): Promise<string | undefined>;
+    definitionInfo(node: Node): Promise<protocol.DefinitionInfo | undefined>;
+    /**
+     * get a definition for a given node.
+     */
+    definition(definition: protocol.DefinitionInfo): Promise<Node | undefined>;
+    /**
+     * visit a definition for node - e.g. return it's schema.
+     */
+    visitDefinition(node: Node): Promise<SchemaNode | undefined>;
+    visit(node: Node): Promise<SchemaNode>;
+    references(): void;
+    isExported(): void;
+    isFromComponent(): void;
+    getFileIdentifiers(exportDec: ExportDeclaration | ExportAssignment): Promise<Identifier[]>;
+    getFileExports(exportDec: ExportDeclaration | ExportAssignment): Promise<ExportIdentifier[]>;
+    getFileInternals(exportDec: ExportDeclaration | ExportAssignment): Promise<Identifier[]>;
+    getIdentifiers(node: Node): Promise<Identifier[]>;
+    /**
+     * 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).
+     */
+    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): Promise<SchemaNode>;
+    private getCompIdByPkgName;
+    getTypeRef(typeStr: string, filePath: string, location: Location): Promise<TypeRefSchema | undefined>;
+    resolveTypeRef(identifier: Identifier, location: Location, isExportedFromMain?: boolean): Promise<TypeRefSchema>;
+    getTypeRefForExternalNode(node: Node): Promise<TypeRefSchema>;
+    getTypeRefForExternalPath(typeStr: string, filePath: string, location: Location): Promise<TypeRefSchema>;
+    jsDocToDocSchema(node: Node): Promise<DocSchema | undefined>;
+}