@teambit/typescript 0.0.0-004aea01bc027e428dfd0f6583f49a1b8286bdd0

package/transformers/tuple-type.ts

@@ -0,0 +1,25 @@
+import type { Node, TupleTypeNode } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import pMapSeries from 'p-map-series';
+import { TupleTypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class TupleTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TupleType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TupleTypeNode, context: SchemaExtractorContext) {
+    const elements = await pMapSeries(node.elements, async (elem) => {
+      const typeSchema = await context.computeSchema(elem);
+      return typeSchema;
+    });
+    return new TupleTypeSchema(context.getLocation(node), elements);
+  }
+}

package/transformers/type-alias.ts

@@ -0,0 +1,27 @@
+import type { Node, TypeAliasDeclaration } from 'typescript';
+import ts from 'typescript';
+import { TypeSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+export class TypeAliasTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeAliasDeclaration;
+  }
+
+  async getIdentifiers(node: TypeAliasDeclaration) {
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  private getName(node: TypeAliasDeclaration): string {
+    return node.name.getText();
+  }
+
+  async transform(typeAlias: TypeAliasDeclaration, context: SchemaExtractorContext) {
+    const type = await context.computeSchema(typeAlias.type);
+    const displaySig = await context.getQuickInfoDisplayString(typeAlias.name);
+    const doc = await context.jsDocToDocSchema(typeAlias);
+    return new TypeSchema(context.getLocation(typeAlias), this.getName(typeAlias), type, displaySig, doc);
+  }
+}

package/transformers/type-literal.ts

@@ -0,0 +1,27 @@
+import type { Node, TypeLiteralNode } from 'typescript';
+import ts from 'typescript';
+import { TypeLiteralSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+/**
+ * not to be confused with "LiteralType", which is string/boolean/null.
+ * this "TypeLiteral" is an object with properties, such as: `{ a: string; b: number }`, similar to Interface.
+ */
+export class TypeLiteralTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeLiteral;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeLiteralNode, context: SchemaExtractorContext) {
+    const members = await pMapSeries(node.members, (member) => context.computeSchema(member));
+    const location = context.getLocation(node);
+    return new TypeLiteralSchema(location, members);
+  }
+}

package/transformers/type-operator.ts

@@ -0,0 +1,38 @@
+import type { Node, TypeOperatorNode } from 'typescript';
+import { SyntaxKind } from 'typescript';
+import { TypeOperatorSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+/**
+ * e.g. keyof typeof Foo
+ */
+export class TypeOperatorTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TypeOperator;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeOperatorNode, context: SchemaExtractorContext) {
+    const operatorName = this.getOperatorName(node.operator);
+    const type = await context.computeSchema(node.type);
+    return new TypeOperatorSchema(context.getLocation(node), operatorName, type);
+  }
+
+  getOperatorName(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword) {
+    switch (operator) {
+      case SyntaxKind.KeyOfKeyword:
+        return 'keyof';
+      case SyntaxKind.UniqueKeyword:
+        return 'unique';
+      case SyntaxKind.ReadonlyKeyword:
+        return 'readonly';
+      default:
+        throw new Error(`getOperatorName: unable to find operator name for ${operator}`);
+    }
+  }
+}

package/transformers/type-predicate.ts

@@ -0,0 +1,23 @@
+import type { Node, TypePredicateNode } from 'typescript';
+import { isIdentifier, SyntaxKind } from 'typescript';
+import { TypePredicateSchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class TypePredicateTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === SyntaxKind.TypePredicate;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypePredicateNode, context: SchemaExtractorContext) {
+    const parameterName = isIdentifier(node.parameterName) ? node.parameterName.getText() : 'this';
+    const type = node.type ? await context.computeSchema(node.type) : undefined;
+    const hasAssertsModifier = Boolean(node.assertsModifier);
+    return new TypePredicateSchema(context.getLocation(node), parameterName, type, hasAssertsModifier);
+  }
+}

package/transformers/type-query.ts

@@ -0,0 +1,26 @@
+import type { Node, TypeQueryNode } from 'typescript';
+import ts from 'typescript';
+import { TypeQuerySchema } from '@teambit/semantics.entities.semantic-schema';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+/**
+ * e.g. `typeof Foo`
+ */
+export class TypeQueryTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeQuery;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeQueryNode, context: SchemaExtractorContext) {
+    const displaySig = await context.getQuickInfoDisplayString(node.exprName);
+    const type = await context.resolveType(node.exprName, node.exprName.getText());
+    const location = context.getLocation(node);
+    return new TypeQuerySchema(location, type, displaySig);
+  }
+}

package/transformers/type-reference.ts

@@ -0,0 +1,37 @@
+import type { Node, TypeReferenceNode } from 'typescript';
+import ts from 'typescript';
+import { TypeRefSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+/**
+ * In the following example, `AriaButtonProps` is a type reference
+ * ```ts
+ * import type { AriaButtonProps } from '@react-types/button';
+ * export type ButtonProps = AriaButtonProps & { a: string };
+ * ```
+ */
+export class TypeReferenceTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.TypeReference;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: TypeReferenceNode, context: SchemaExtractorContext) {
+    const name = node.typeName.getText();
+    let type = await context.resolveType(node, name);
+    if (!(type instanceof TypeRefSchema)) {
+      type = new TypeRefSchema(context.getLocation(node), name);
+    }
+    if (node.typeArguments && type instanceof TypeRefSchema) {
+      const args = await pMapSeries(node.typeArguments, (arg) => context.computeSchema(arg));
+      type.withTypeArgs(args);
+    }
+    return type;
+  }
+}

package/transformers/union-type.ts

@@ -0,0 +1,26 @@
+import type { Node, UnionTypeNode } from 'typescript';
+import ts from 'typescript';
+import { TypeUnionSchema } from '@teambit/semantics.entities.semantic-schema';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import type { Identifier } from '../identifier';
+
+export class UnionTypeTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.UnionType;
+  }
+
+  async getIdentifiers(): Promise<Identifier[]> {
+    return [];
+  }
+
+  async transform(node: UnionTypeNode, context: SchemaExtractorContext) {
+    const types = await pMapSeries(node.types, async (type) => {
+      const typeSchema = context.computeSchema(type);
+      return typeSchema;
+    });
+    const location = context.getLocation(node);
+    return new TypeUnionSchema(location, types);
+  }
+}

package/transformers/utils/jsdoc-to-doc-schema.ts

@@ -0,0 +1,114 @@
+/* eslint-disable complexity */
+/* eslint-disable no-fallthrough */
+import type { JSDocParameterTag, JSDocPropertyLikeTag, JSDocPropertyTag, JSDocReturnTag, JSDocTag } from 'typescript';
+import { getTextOfJSDocComment, SyntaxKind } from 'typescript';
+import {
+  PropertyLikeTagSchema,
+  ReturnTagSchema,
+  TagName,
+  TagSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import type { Formatter } from '@teambit/formatter';
+import type { SchemaExtractorContext } from '../../schema-extractor-context';
+
+export async function tagParser(
+  tag: JSDocTag,
+  context: SchemaExtractorContext,
+  formatter?: Formatter
+): Promise<TagSchema> {
+  // for some reason, in some cases, if `tag.getSourceFile()` is not provided to the `getText()`, it throws "Cannot read property 'text' of undefined"
+  switch (tag.kind) {
+    case SyntaxKind.JSDocReturnTag:
+      return returnTag(tag as JSDocReturnTag, context);
+    case SyntaxKind.JSDocPropertyTag:
+      return propertyLikeTag(tag as JSDocPropertyTag, context);
+    case SyntaxKind.JSDocParameterTag:
+      return propertyLikeTag(tag as JSDocParameterTag, context);
+    case SyntaxKind.JSDocAugmentsTag:
+      return simpleTag(tag, TagName.augments, context);
+    case SyntaxKind.JSDocAuthorTag:
+      return simpleTag(tag, TagName.author, context);
+    case SyntaxKind.JSDocClassTag:
+      return simpleTag(tag, TagName.class, context);
+    case SyntaxKind.JSDocCallbackTag:
+      return simpleTag(tag, TagName.callback, context);
+    case SyntaxKind.JSDocPublicTag:
+      return simpleTag(tag, TagName.public, context);
+    case SyntaxKind.JSDocPrivateTag:
+      return simpleTag(tag, TagName.private, context);
+    case SyntaxKind.JSDocProtectedTag:
+      return simpleTag(tag, TagName.protected, context);
+    case SyntaxKind.JSDocReadonlyTag:
+      return simpleTag(tag, TagName.readonly, context);
+    case SyntaxKind.JSDocOverrideTag:
+      return simpleTag(tag, TagName.override, context);
+    case SyntaxKind.JSDocDeprecatedTag:
+      return simpleTag(tag, TagName.deprecated, context);
+    case SyntaxKind.JSDocSeeTag:
+      return simpleTag(tag, TagName.see, context);
+    case SyntaxKind.JSDocEnumTag:
+      return simpleTag(tag, TagName.enum, context);
+    case SyntaxKind.JSDocThisTag:
+      return simpleTag(tag, TagName.this, context);
+    case SyntaxKind.JSDocTypeTag:
+      return simpleTag(tag, TagName.type, context);
+    case SyntaxKind.JSDocTemplateTag:
+      return simpleTag(tag, TagName.template, context);
+    case SyntaxKind.JSDocTypedefTag:
+      return simpleTag(tag, TagName.typedef, context);
+    case SyntaxKind.JSDocImplementsTag:
+      return simpleTag(tag, TagName.implements, context);
+    default: {
+      const tagName: TagName | string = tag.tagName.getText(tag.getSourceFile());
+      if (tagName === 'example') {
+        const comment = getTextOfJSDocComment(tag.comment);
+        if (!formatter) return simpleTag(tag, tagName, context);
+        try {
+          const extractedSnippetToFormat = comment && extractCodeBlock(comment);
+          const formattedComment =
+            extractedSnippetToFormat && (await formatter.formatSnippet(extractedSnippetToFormat.code));
+          return new TagSchema(context.getLocation(tag), tagName, formattedComment ?? undefined);
+        } catch {
+          return simpleTag(tag, tagName, context);
+        }
+      }
+
+      return simpleTag(tag, tagName, context);
+    }
+  }
+}
+
+function simpleTag(tag: JSDocTag, tagName: TagName | string, context: SchemaExtractorContext): TagSchema {
+  return new TagSchema(context.getLocation(tag), tagName, getTextOfJSDocComment(tag.comment));
+}
+
+async function returnTag(tag: JSDocReturnTag, context: SchemaExtractorContext) {
+  const type = tag.typeExpression?.type ? await context.computeSchema(tag.typeExpression?.type) : undefined;
+  return new ReturnTagSchema(context.getLocation(tag), getTextOfJSDocComment(tag.comment), type);
+}
+
+async function propertyLikeTag(tag: JSDocPropertyLikeTag, context: SchemaExtractorContext) {
+  const type = tag.typeExpression?.type ? await context.computeSchema(tag.typeExpression?.type) : undefined;
+  return new PropertyLikeTagSchema(
+    context.getLocation(tag),
+    tag.name.getText(),
+    getTextOfJSDocComment(tag.comment),
+    type
+  );
+}
+
+function extractCodeBlock(text: string): { lang: string; code: string } | null {
+  let processedText = text;
+  if (text.endsWith(';') && !text.endsWith('```')) {
+    processedText = text.slice(0, -1) + '```';
+  }
+  const regex = /```([\w+-]*)\s*([\s\S]*?)```/;
+  const match = processedText.match(regex);
+
+  if (match) {
+    const lang = match[1];
+    const code = match[2];
+    return { lang, code };
+  }
+  return null;
+}

package/transformers/utils/parse-type-from-quick-info.ts

@@ -0,0 +1,99 @@
+import type ts from 'typescript/lib/tsserverlibrary';
+
+export const UNRESOLVED = '<<unresolved>>';
+
+/**
+ * try to parse the type from the quickinfo.
+ * this is an error-prone process, we do our best here.
+ *
+ * an example of a function with many ":"
+ * `export function getObj(a: string, func: (b: number) => {}) { return { a: 1, b: 2 } };`
+ * which produce the following quickinfo:
+ * ```ts
+ * function getObj(a: string, func: (b: number) => {}): {
+ *   a: number;
+ *   b: number;
+ * }
+ * ```
+ *
+ * some examples of quickinfo:
+ *
+ * function ts.signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags): SymbolDisplayPart[]
+ *
+ * const enum ts.TypeFormatFlags
+ *
+ * (method) ts.TypeChecker.writeSignature(signature: Signature, enclosingDeclaration?: Node | undefined, flags?: TypeFormatFlags | undefined, kind?: SignatureKind | undefined, writer?: EmitTextWriter | undefined): string
+ *
+ * const obj: {
+ *   a: number;
+ *   b: number;
+ *  }
+ *
+ * function getObj(a: string): {
+ *     a: number;
+ *     b: number;
+ * }
+ */
+export function parseTypeFromQuickInfo(quickInfo: ts.server.protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo?.body?.displayString) return '';
+  const displayString = quickInfo.body.displayString;
+  const splitByColon = displayString.split(':');
+  switch (quickInfo.body.kind) {
+    case 'type parameter':
+      // (type parameter) T in concat<T, K, V>(array1: T[], array2: T[]): T[]
+      return displayString.replace(`(${quickInfo.body.kind}) `, '').split(' ')[0];
+    case 'const':
+    case 'property':
+    case 'let':
+    case 'getter':
+    case 'var': {
+      const [, ...tail] = splitByColon;
+      return tail.join(':').trim();
+    }
+    case 'method':
+    case 'function': {
+      const split = displayString.split('): ');
+      if (split.length !== 2) {
+        // it's hard to determine where the return-type is. so it's better to show unresolved.
+        // maybe, in the UI, in this case, it's best to show the signature.
+        // e.g.
+        // (method) IssuesList.getIssue<T extends ComponentIssue>(IssueClass: {
+        //   new (): T;
+        // }): T | undefined
+        return UNRESOLVED;
+      }
+      return split[1].trim();
+    }
+    case 'alias': {
+      // e.g. (alias) class BuilderService\nimport BuilderService
+      // e.g. '(alias) type Serializable = {\n' +
+      // '    toString(): string;\n' +
+      // '}\n' +
+      // 'import Serializable'
+      const firstLine = displayString.split('\n')[0];
+      const splitBySpace = firstLine.trim().split(' ');
+      // first two are alias keyword and alias type
+      const [, , typeName] = splitBySpace;
+      return typeName;
+    }
+    case 'type': {
+      // e.g. `type TaskSlot = SlotRegistry<BuildTask[]>`
+      const splitByEqual = displayString.split('=');
+      const [, ...tail] = splitByEqual;
+      return tail.join('=').trim();
+    }
+    case 'parameter': {
+      const typeColonIndex = displayString.indexOf(':');
+      return displayString.slice(typeColonIndex + 1).trim();
+    }
+    default:
+      return splitByColon[splitByColon.length - 1].trim();
+  }
+}
+
+export function parseReturnTypeFromQuickInfo(quickInfo: ts.server.protocol.QuickInfoResponse | undefined): string {
+  if (!quickInfo) return '';
+  const typeStr = parseTypeFromQuickInfo(quickInfo);
+  const array = typeStr.split('=>');
+  return array[array.length - 1].trim();
+}

package/transformers/variable-declaration.ts

@@ -0,0 +1,111 @@
+import type { SchemaNode, Modifier } from '@teambit/semantics.entities.semantic-schema';
+import {
+  VariableLikeSchema,
+  FunctionLikeSchema,
+  ParameterSchema,
+  TypeRefSchema,
+} from '@teambit/semantics.entities.semantic-schema';
+import type { Node, VariableDeclaration as VariableDeclarationNode, ArrowFunction } from 'typescript';
+import ts from 'typescript';
+import pMapSeries from 'p-map-series';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { parseTypeFromQuickInfo } from './utils/parse-type-from-quick-info';
+import { Identifier } from '../identifier';
+import { ParameterTransformer } from './parameter';
+
+export class VariableDeclaration implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.VariableDeclaration;
+  }
+
+  getName(node: VariableDeclarationNode) {
+    return node.name.getText();
+  }
+
+  async getIdentifiers(node: VariableDeclarationNode) {
+    return [new Identifier(node.name.getText(), node.getSourceFile().fileName)];
+  }
+
+  async transform(varDec: VariableDeclarationNode, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const name = this.getName(varDec);
+    const info = await context.getQuickInfo(varDec.name);
+    const displaySig = info?.body?.displayString || '';
+    const location = context.getLocation(varDec);
+    const doc = await context.jsDocToDocSchema(varDec);
+    const nodeModifiers = ts.canHaveModifiers(varDec) ? ts.getModifiers(varDec) : undefined;
+    const modifiers = nodeModifiers?.map((modifier) => modifier.getText()) || [];
+    if (varDec.initializer?.kind === ts.SyntaxKind.ArrowFunction) {
+      const functionLikeInfo = await context.getQuickInfo((varDec.initializer as ArrowFunction).equalsGreaterThanToken);
+      const returnTypeStr = functionLikeInfo ? parseTypeFromQuickInfo(functionLikeInfo) : 'any';
+      // example => export const useLanesContext: () => LanesContextModel | undefined = () => {
+      if (varDec.type) {
+        const funcType = await context.resolveType(varDec, '');
+        if (isFunctionLike(funcType)) {
+          return new FunctionLikeSchema(
+            location,
+            name,
+            funcType.params,
+            funcType.returnType,
+            functionLikeInfo?.body?.displayString || '',
+            modifiers as Modifier[],
+            doc
+          );
+        }
+        // e.g. export const MyComponent: React.FC<T> = ({}) => {}
+        if (funcType instanceof TypeRefSchema) {
+          const paramTypes = funcType.typeArgs;
+          const params = (varDec.initializer as ArrowFunction).parameters;
+          const paramsSchema = await pMapSeries(params, async (param, index) => {
+            const objectBindingNodes = await ParameterTransformer.getObjectBindingNodes(
+              param,
+              paramTypes?.[index] ?? funcType,
+              context
+            );
+            return new ParameterSchema(
+              location,
+              ParameterTransformer.getName(param),
+              paramTypes?.[index] ?? funcType,
+              Boolean(param.questionToken),
+              param.initializer ? param.initializer.getText() : undefined,
+              undefined,
+              objectBindingNodes,
+              Boolean(param.dotDotDotToken)
+            );
+          });
+
+          return new FunctionLikeSchema(
+            location,
+            name,
+            paramsSchema,
+            await context.resolveType(varDec.initializer, returnTypeStr),
+            functionLikeInfo?.body?.displayString || '',
+            modifiers as Modifier[],
+            doc
+          );
+        }
+      }
+      const args = (await pMapSeries((varDec.initializer as ArrowFunction).parameters, async (param) =>
+        context.computeSchema(param)
+      )) as ParameterSchema[];
+      return new FunctionLikeSchema(
+        location,
+        name,
+        args,
+        await context.resolveType(varDec.initializer, returnTypeStr),
+        functionLikeInfo?.body?.displayString || '',
+        modifiers as Modifier[],
+        doc
+      );
+    }
+    const typeStr = parseTypeFromQuickInfo(info);
+    const type = await context.resolveType(varDec, typeStr);
+    const defaultValue = varDec.initializer ? varDec.initializer.getText() : undefined;
+
+    return new VariableLikeSchema(location, name, displaySig, type, false, doc, defaultValue);
+  }
+}
+
+function isFunctionLike(node: SchemaNode): node is FunctionLikeSchema {
+  return node instanceof FunctionLikeSchema;
+}

package/transformers/variable-statement.ts

@@ -0,0 +1,34 @@
+import type { SchemaNode } from '@teambit/semantics.entities.semantic-schema';
+import { ModuleSchema } from '@teambit/semantics.entities.semantic-schema';
+import { compact } from 'lodash';
+import pMapSeries from 'p-map-series';
+import type { Node, VariableStatement } from 'typescript';
+import ts from 'typescript';
+import type { SchemaTransformer } from '../schema-transformer';
+import type { SchemaExtractorContext } from '../schema-extractor-context';
+import { Identifier } from '../identifier';
+
+/**
+ * variable statement is a collection of variable declarations.
+ * e.g. `export const a = 1, b = () => {}, c = {};`
+ */
+export class VariableStatementTransformer implements SchemaTransformer {
+  predicate(node: Node) {
+    return node.kind === ts.SyntaxKind.VariableStatement;
+  }
+
+  async getIdentifiers(node: VariableStatement) {
+    return node.declarationList.declarations.map((dec) => {
+      return new Identifier(dec.name.getText(), dec.getSourceFile().fileName);
+    });
+  }
+
+  async transform(node: VariableStatement, context: SchemaExtractorContext): Promise<SchemaNode> {
+    const schemas = await pMapSeries(node.declarationList.declarations, async (dec) => {
+      // this will get the schema from variable-declaration
+      const schema = await context.visitDefinition(dec.name);
+      return schema;
+    });
+    return new ModuleSchema(context.getLocation(node), compact(schemas), []);
+  }
+}

package/types/asset.d.ts

@@ -0,0 +1,41 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<
+    SVGProps<SVGSVGElement> & { title?: string }
+  >;
+  const src: string;
+  export default src;
+}
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}
+declare module '*.otf' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff' {
+  const value: any;
+  export = value;
+}
+declare module '*.woff2' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}