@teambit/semantics.entities.semantic-schema 0.0.0-e4ef0e951da794f03096a5cc407420f4cde8b878

package/schemas/export.ts

@@ -0,0 +1,91 @@
+import { SchemaNode, SchemaLocation } from '../schema-node';
+import { DocSchema } from './docs';
+import { SchemaRegistry } from '../schema-registry';
+
+export class ExportSchema extends SchemaNode {
+  alias?: string;
+  exportNode: SchemaNode;
+  readonly doc?: DocSchema;
+  readonly signature?: string;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    exportNode: SchemaNode,
+    alias?: string,
+    doc?: DocSchema
+  ) {
+    super();
+    this.exportNode = exportNode;
+    this.alias = alias;
+    this.doc = doc;
+    this.signature = exportNode.signature || this.toFullSignature();
+  }
+
+  toString(options?: { color?: boolean }): string {
+    let signature = '';
+
+    const alias = this.alias || this.name;
+    const originalName = this.exportNode.name || this.name;
+
+    if (alias !== originalName) {
+      signature += `export { ${originalName} as ${alias} };\n`;
+    } else {
+      signature += `export { ${originalName} };\n`;
+    }
+
+    const exportNodeSignature = this.exportNode.toString(options);
+
+    signature += `\n${exportNodeSignature}`;
+
+    return signature;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let signature = '';
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature += `${docString}\n`;
+    }
+
+    const alias = this.alias || this.name;
+    const originalName = this.exportNode.name || this.name;
+
+    if (alias !== originalName) {
+      signature += `export { ${originalName} as ${alias} };\n`;
+    } else {
+      signature += `export { ${originalName} };\n`;
+    }
+
+    const exportNodeSignature = this.exportNode.toFullSignature(options);
+
+    signature += `\n${exportNodeSignature}`;
+
+    return signature;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      doc: this.doc?.toObject(),
+      location: this.location,
+      exportNode: this.exportNode.toObject(),
+      alias: this.alias,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ExportSchema {
+    const name = obj.name;
+    const location = obj.location;
+    const exportNode = SchemaRegistry.fromObject(obj.exportNode);
+    const alias = obj.alias;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new ExportSchema(location, name, exportNode, alias, doc);
+  }
+
+  static isExportSchema(node: SchemaNode): node is ExportSchema {
+    return 'exportNode' in node;
+  }
+}

package/schemas/expression-with-arguments.ts

@@ -0,0 +1,51 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class ExpressionWithTypeArgumentsSchema extends SchemaNode {
+  readonly typeArgs: SchemaNode[];
+  readonly expression: SchemaNode;
+
+  constructor(
+    typeArgs: SchemaNode[],
+    expression: SchemaNode,
+    readonly name: string,
+    readonly location: SchemaLocation
+  ) {
+    super();
+    this.typeArgs = typeArgs;
+    this.expression = expression;
+  }
+
+  toString() {
+    return this.name;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = this.name;
+
+    if (this.typeArgs && this.typeArgs.length > 0) {
+      const typeArgsStr = this.typeArgs.map((arg) => arg.toFullSignature(options)).join(', ');
+      result += `<${typeArgsStr}>`;
+    }
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      location: this.location,
+      typeArgs: this.typeArgs.map((typeArg) => typeArg.toObject()),
+      expression: this.expression,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ExpressionWithTypeArgumentsSchema {
+    const name = obj.name;
+    const location = obj.location;
+    const typeArgs = obj.typeArgs.map((typeArg: any) => SchemaRegistry.fromObject(typeArg));
+    const expression = SchemaRegistry.fromObject(obj.expression);
+    return new ExpressionWithTypeArgumentsSchema(typeArgs, expression, name, location);
+  }
+}

package/schemas/function-like.ts

@@ -0,0 +1,154 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { ParameterSchema } from './parameter';
+import { DocSchema } from './docs';
+import { TagName } from './docs/tag';
+import { SchemaRegistry } from '../schema-registry';
+
+export type Modifier =
+  | 'static'
+  | 'public'
+  | 'private'
+  | 'protected'
+  | 'readonly'
+  | 'abstract'
+  | 'async'
+  | 'override'
+  | 'export';
+
+/**
+ * function-like can be a function, method, arrow-function, variable-function, etc.
+ */
+export class FunctionLikeSchema extends SchemaNode {
+  readonly returnType: SchemaNode;
+  readonly params: ParameterSchema[];
+  readonly doc?: DocSchema;
+  readonly signature?: string | undefined;
+  readonly displaySchemaName = 'Functions';
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    params: ParameterSchema[],
+    returnType: SchemaNode,
+    signature: string,
+    readonly modifiers: Modifier[] = [],
+    doc?: DocSchema,
+    readonly typeParams?: string[],
+    readonly decorators?: SchemaNode[]
+  ) {
+    super();
+    this.params = params;
+    this.returnType = returnType;
+    this.doc = doc;
+    this.signature = signature || FunctionLikeSchema.createSignature(this.name, this.params, this.returnType);
+  }
+
+  getNodes() {
+    return [...this.params, this.returnType, ...(this.decorators || [])];
+  }
+
+  toString(options?: { color?: boolean }) {
+    const bold = options?.color ? chalk.bold : (text: string) => text;
+    const paramsStr = this.params.map((param) => param.toString()).join(', ');
+    const typeParamsStr = this.typeParams ? `<${this.typeParams.join(', ')}>` : '';
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString(options)).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${this.modifiersToString()}${typeParamsStr}${bold(
+      this.name
+    )}(${paramsStr}): ${this.returnType.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString()).join('\n');
+    if (decoratorsStr) {
+      result += `${decoratorsStr}\n`;
+    }
+    const modifiersStr = this.modifiersToString();
+    const typeParamsStr = this.typeParams ? `<${this.typeParams.join(', ')}>` : '';
+    const paramsStr = this.params
+      .map((param) => {
+        let paramStr = '';
+        if (param.isSpread) {
+          paramStr += '...';
+        }
+        paramStr += param.name;
+        if (param.isOptional) {
+          paramStr += '?';
+        }
+        paramStr += `: ${param.type.toString()}`;
+        if (param.defaultValue !== undefined) {
+          paramStr += ` = ${param.defaultValue}`;
+        }
+        return paramStr;
+      })
+      .join(', ');
+    result += `${modifiersStr}${this.name}${typeParamsStr}(${paramsStr}): ${this.returnType.toString()}`;
+    return result;
+  }
+
+  isDeprecated(): boolean {
+    return Boolean(this.doc?.hasTag(TagName.deprecated));
+  }
+
+  isPrivate(): boolean {
+    return Boolean(this.modifiers.find((m) => m === 'private') || this.doc?.hasTag(TagName.private));
+  }
+
+  generateSignature(): string {
+    return FunctionLikeSchema.createSignature(this.name, this.params, this.returnType, this.decorators);
+  }
+
+  static createSignature(
+    name: string,
+    params: ParameterSchema[],
+    returnType: SchemaNode,
+    decorators?: SchemaNode[]
+  ): string {
+    const paramsStr = params
+      .map((param) => {
+        let type = param.type.toString();
+        if (param.isSpread) type = `...${type}`;
+        return `${param.name}${param.isOptional ? '?' : ''}: ${type}`;
+      })
+      .join(', ');
+    const decoratorsStr = decorators?.map((decorator) => decorator.toString()).join('\n');
+    return `${decorators ? `${decoratorsStr}\n` : ''}${name}(${paramsStr}): ${returnType.toString()}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      params: this.params.map((param) => param.toObject()),
+      returnType: this.returnType.toObject(),
+      signature: this.signature,
+      modifiers: this.modifiers,
+      doc: this.doc?.toObject(),
+      typeParams: this.typeParams,
+      decorators: this.decorators?.map((decorator) => decorator.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>) {
+    return new FunctionLikeSchema(
+      obj.location,
+      obj.name,
+      obj.params.map((param: Record<string, any>) => ParameterSchema.fromObject(param)),
+      SchemaRegistry.fromObject(obj.returnType),
+      obj.signature,
+      obj.modifiers,
+      obj.doc ? DocSchema.fromObject(obj.doc) : undefined,
+      obj.typeParams,
+      obj.decorators?.map((decorator) => SchemaRegistry.fromObject(decorator))
+    );
+  }
+
+  private modifiersToString() {
+    const modifiersToPrint = this.modifiers.filter((modifier) => modifier !== 'export');
+    return modifiersToPrint.length ? `${modifiersToPrint.join(' ')} ` : '';
+  }
+}

package/schemas/get-accessor.ts

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class GetAccessorSchema extends SchemaNode {
+  readonly type: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    type: SchemaNode,
+    readonly signature: string
+  ) {
+    super();
+    this.type = type;
+  }
+  getSignature() {
+    return this.signature;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }): string {
+    const bold = options?.color ? chalk.bold : (x: string) => x;
+    return `get ${bold(this.name)}(): ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    result += `get ${this.name}(): ${this.type.toFullSignature(options)}`;
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject(),
+      signature: this.signature,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): GetAccessorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const signature = obj.signature;
+    return new GetAccessorSchema(location, name, type, signature);
+  }
+}

package/schemas/ignored.ts

@@ -0,0 +1,43 @@
+import { DocSchema, SchemaRegistry } from '..';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+export class IgnoredSchema extends SchemaNode {
+  public location: SchemaLocation;
+  public doc?: DocSchema;
+  public name?: string;
+
+  constructor(public readonly node: SchemaNode) {
+    super();
+    this.location = node.location;
+    this.doc = node.doc;
+    this.name = node.name;
+  }
+
+  getNodes() {
+    return [];
+  }
+
+  getAllNodesRecursively(): SchemaNode[] {
+    return [];
+  }
+
+  toString() {
+    return '';
+  }
+
+  toFullSignature(): string {
+    return '';
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      node: this.node.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): IgnoredSchema {
+    const node = SchemaRegistry.fromObject(obj.node);
+    return new IgnoredSchema(node);
+  }
+}

package/schemas/index-signature.ts

@@ -0,0 +1,49 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+import { ParameterSchema } from './parameter';
+
+/**
+ * [key: number]: string
+ * keyType: number
+ * valueType: string
+ */
+export class IndexSignatureSchema extends SchemaNode {
+  readonly keyType: SchemaNode;
+  readonly valueType: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    keyType: ParameterSchema,
+    valueType: SchemaNode
+  ) {
+    super();
+    this.keyType = keyType;
+    this.valueType = valueType;
+  }
+
+  toString() {
+    return `[${this.keyType.toString()}]: ${this.valueType.toString()}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const keyTypeStr = this.keyType.toFullSignature(options);
+    const valueTypeStr = this.valueType.toFullSignature(options);
+
+    return `[${keyTypeStr}]: ${valueTypeStr}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      location: this.location,
+      keyType: this.keyType.toObject(),
+      valueType: this.valueType.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): IndexSignatureSchema {
+    const location = obj.location;
+    const keyType = ParameterSchema.fromObject(obj.keyType);
+    const valueType = SchemaRegistry.fromObject(obj.valueType);
+    return new IndexSignatureSchema(location, keyType, valueType);
+  }
+}

package/schemas/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Ensure that any new Schema class ends with the word 'Schema'
+ * This will make sure that the Class Name is not minimized during prod bundling process
+ * and the schemaObjToClass can match and instantiate the Schema Class correctly
+ */
+export { ModuleSchema } from './module';
+export { FunctionLikeSchema } from './function-like';
+export { TypeRefSchema } from './type-ref';
+export { VariableLikeSchema } from './variable-like';
+export { ClassSchema } from './class';
+export { ConstructorSchema } from './constructor';
+export { TypeSchema } from './type';
+export { TypeIntersectionSchema } from './type-intersection';
+export { TypeUnionSchema } from './type-union';
+export { TypeLiteralSchema } from './type-literal';
+export { IndexSignatureSchema } from './index-signature';
+export { InterfaceSchema } from './interface';
+export { GetAccessorSchema } from './get-accessor';
+export { SetAccessorSchema } from './set-accessor';
+export { TypeQuerySchema } from './type-query';
+export { InferenceTypeSchema } from './inference-type';
+export { LiteralTypeSchema } from './literal-type';
+export { KeywordTypeSchema } from './keyword-type';
+export { TypeArraySchema } from './type-array';
+export { TypeOperatorSchema } from './type-operator';
+export { TupleTypeSchema } from './tuple-type';
+export { ParameterSchema } from './parameter';
+export { EnumSchema } from './enum';
+export { EnumMemberSchema } from './enum-member';
+export { ParenthesizedTypeSchema } from './parenthesized-type';
+export { TypePredicateSchema } from './type-predicate';
+export { IndexedAccessSchema } from './indexed-access-type';
+export { TemplateLiteralTypeSchema } from './template-literal-type';
+export { TemplateLiteralTypeSpanSchema } from './template-literal-type-span';
+export { ThisTypeSchema } from './this-type';
+export { UnknownSchema } from './unknown-schema';
+export { UnresolvedSchema } from './unresolved-schema';
+export { ConditionalTypeSchema } from './conditional-type';
+export { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';
+export { NamedTupleSchema } from './named-tuple';
+export { UnImplementedSchema } from './unimplemented-schema';
+export { ObjectLiteralExpressionSchema } from './object-literal-expression';
+export { ArrayLiteralExpressionSchema } from './array-literal-expression';
+export { PropertyAssignmentSchema } from './property-assignment';
+export { DecoratorSchema } from './decorator';
+export { LiteralValueSchema } from './literal-value';
+export { IgnoredSchema } from './ignored';
+export { ExportSchema } from './export';
+export * from './docs';

package/schemas/indexed-access-type.ts

@@ -0,0 +1,47 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class IndexedAccessSchema extends SchemaNode {
+  readonly objectType: SchemaNode;
+  readonly indexType: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    objectType: SchemaNode,
+    indexType: SchemaNode
+  ) {
+    super();
+    this.objectType = objectType;
+    this.indexType = indexType;
+  }
+
+  getNodes() {
+    return [this.objectType, this.indexType];
+  }
+
+  toString() {
+    return `${this.objectType.toString()}[${this.indexType.toString()}]`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const objectTypeStr = this.objectType.toFullSignature(options);
+    const indexTypeStr = this.indexType.toFullSignature(options);
+
+    return `${objectTypeStr}[${indexTypeStr}]`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      objectType: this.objectType.toObject(),
+      indexType: this.indexType.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): IndexedAccessSchema {
+    const location = obj.location;
+    const objectType = SchemaRegistry.fromObject(obj.objectType);
+    const indexType = SchemaRegistry.fromObject(obj.indexType);
+    return new IndexedAccessSchema(location, objectType, indexType);
+  }
+}

package/schemas/inference-type.ts

@@ -0,0 +1,60 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+/**
+ * where there is no explicit type, the type is taken from the "quickinfo" of tsserver
+ */
+export class InferenceTypeSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly type: string,
+    readonly name?: string,
+    readonly defaultValue?: string,
+    readonly isSpread?: boolean,
+    readonly alias?: string
+  ) {
+    super();
+  }
+
+  toString() {
+    if (this.name && this.name !== this.type) {
+      return `${this.name}: ${this.type}`;
+    }
+    return this.type;
+  }
+
+  toFullSignature(): string {
+    let result = '';
+
+    if (this.name && this.name !== this.type) {
+      result += `${this.name}: `;
+    }
+
+    result += this.type;
+
+    if (this.defaultValue !== undefined) {
+      result += ` = ${this.defaultValue}`;
+    }
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type,
+      defaultValue: this.defaultValue,
+      isSpread: this.isSpread,
+      alias: this.alias,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): InferenceTypeSchema {
+    const location = obj.location;
+    const type = obj.type;
+    const name = obj.name;
+    const defaultValue = obj.defaultValue;
+    const isSpread = obj.isSpread;
+    const alias = obj.alias;
+    return new InferenceTypeSchema(location, type, name, defaultValue, isSpread, alias);
+  }
+}

package/schemas/interface.ts

@@ -0,0 +1,94 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+import { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';
+import { SchemaRegistry } from '../schema-registry';
+
+export class InterfaceSchema extends SchemaNode {
+  readonly members: SchemaNode[];
+  readonly doc?: DocSchema;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly signature: string,
+    readonly extendsNodes: ExpressionWithTypeArgumentsSchema[],
+    members: SchemaNode[],
+    doc?: DocSchema,
+    readonly typeParams?: string[]
+  ) {
+    super();
+    this.members = members;
+    this.doc = doc;
+  }
+
+  getNodes() {
+    return this.members;
+  }
+
+  toString(options?: { color?: boolean }): string {
+    const boldUnderline = options?.color ? chalk.bold.underline : (str: string) => str;
+    const membersStr = this.members.map((m) => `* ${m.toString(options)}`).join('\n');
+    return `${boldUnderline(this.name)}\n${membersStr}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    let interfaceDeclaration = `interface ${this.name}`;
+
+    if (this.typeParams && this.typeParams.length > 0) {
+      interfaceDeclaration += `<${this.typeParams.join(', ')}>`;
+    }
+
+    if (this.extendsNodes && this.extendsNodes.length > 0) {
+      const extendsStr = this.extendsNodes.map((node) => node.toFullSignature(options)).join(', ');
+      interfaceDeclaration += ` extends ${extendsStr}`;
+    }
+
+    result += `${interfaceDeclaration} {\n`;
+
+    const membersStr = this.members
+      .map((member) => {
+        const memberStr = member.toFullSignature(options);
+        return memberStr
+          .split('\n')
+          .map((line) => `  ${line}`)
+          .join('\n');
+      })
+      .join('\n');
+
+    result += `${membersStr}\n`;
+
+    result += `}`;
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      members: this.members.map((member) => member.toObject()),
+      doc: this.doc?.toObject(),
+      signature: this.signature,
+      extendsNodes: this.extendsNodes?.map((node) => node.toObject()),
+      typeParams: this.typeParams,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): InterfaceSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const signature = obj.signature;
+    const extendsNodes = obj.extendsNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const members = obj.members.map((member: any) => SchemaRegistry.fromObject(member));
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const typeParams = obj.typeParams;
+    return new InterfaceSchema(location, name, signature, extendsNodes, members, doc, typeParams);
+  }
+}