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

package/schemas/class.ts

@@ -0,0 +1,135 @@
+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 ClassSchema extends SchemaNode {
+  readonly members: SchemaNode[];
+  readonly doc?: DocSchema;
+
+  constructor(
+    readonly name: string,
+    members: SchemaNode[],
+    readonly location: SchemaLocation,
+    readonly signature: string,
+    doc?: DocSchema,
+    readonly typeParams?: string[],
+    readonly extendsNodes?: ExpressionWithTypeArgumentsSchema[],
+    readonly implementNodes?: ExpressionWithTypeArgumentsSchema[],
+    readonly decorators?: SchemaNode[]
+  ) {
+    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');
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString(options)).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${boldUnderline(this.name)}\n${membersStr}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toFullSignature(options)).join('\n');
+    if (decoratorsStr) {
+      result += `${decoratorsStr}\n`;
+    }
+
+    let classDeclaration = `class ${this.name}`;
+
+    if (this.typeParams && this.typeParams.length > 0) {
+      classDeclaration += `<${this.typeParams.join(', ')}>`;
+    }
+
+    if (this.extendsNodes && this.extendsNodes.length > 0) {
+      const extendsStr = this.extendsNodes.map((node) => node.toFullSignature(options)).join(', ');
+      classDeclaration += ` extends ${extendsStr}`;
+    }
+
+    if (this.implementNodes && this.implementNodes.length > 0) {
+      const implementsStr = this.implementNodes.map((node) => node.toFullSignature(options)).join(', ');
+      classDeclaration += ` implements ${implementsStr}`;
+    }
+
+    result += `${classDeclaration} {\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,
+      typeParams: this.typeParams,
+      extendsNodes: this.extendsNodes?.map((node) => node.toObject()),
+      implementNodes: this.implementNodes?.map((node) => node.toObject()),
+      decorators: this.decorators?.map((decorator) => decorator.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ClassSchema {
+    const name = obj.name;
+    const members = obj.members.map((member: any) => SchemaRegistry.fromObject(member));
+    const location = obj.location;
+    const signature = obj.signature;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const typeParams = obj.typeParams;
+    const extendsNodes = obj.extendsNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const implementNodes = obj.implementNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const decorators = obj.decorators?.map((decorator: any) => SchemaRegistry.fromObject(decorator));
+    return new ClassSchema(
+      name,
+      members,
+      location,
+      signature,
+      doc,
+      typeParams,
+      extendsNodes,
+      implementNodes,
+      decorators
+    );
+  }
+
+  static fromSchema(node: ClassSchema, memberTransformer: (_node: SchemaNode) => SchemaNode = (_node) => _node) {
+    return new ClassSchema(
+      node.name,
+      node.members.map(memberTransformer),
+      node.location,
+      node.signature,
+      node.doc,
+      node.typeParams,
+      node.extendsNodes,
+      node.implementNodes,
+      node.decorators
+    );
+  }
+}

package/schemas/conditional-type.ts

@@ -0,0 +1,63 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+/**
+ * e.g. `T extends U ? Y : N`
+ *
+ */
+export class ConditionalTypeSchema extends SchemaNode {
+  readonly checkType: SchemaNode;
+  readonly extendsType: SchemaNode;
+  readonly trueType: SchemaNode;
+  readonly falseType: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    checkType: SchemaNode,
+    extendsType: SchemaNode,
+    trueType: SchemaNode,
+    falseType: SchemaNode
+  ) {
+    super();
+    this.checkType = checkType;
+    this.extendsType = extendsType;
+    this.trueType = trueType;
+    this.falseType = falseType;
+  }
+
+  getNodes() {
+    return [this.checkType, this.extendsType, this.trueType, this.falseType];
+  }
+
+  toString() {
+    return `${this.checkType.toString()} extends ${this.extendsType.toString()} ? ${this.trueType.toString()} : ${this.falseType.toString()}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const checkTypeStr = this.checkType.toFullSignature(options);
+    const extendsTypeStr = this.extendsType.toFullSignature(options);
+    const trueTypeStr = this.trueType.toFullSignature(options);
+    const falseTypeStr = this.falseType.toFullSignature(options);
+
+    return `${checkTypeStr} extends ${extendsTypeStr} ? ${trueTypeStr} : ${falseTypeStr}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      checkType: this.checkType.toObject(),
+      extendsType: this.extendsType.toObject(),
+      trueType: this.trueType.toObject(),
+      falseType: this.falseType.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ConditionalTypeSchema {
+    const location = obj.location;
+    const checkType = SchemaRegistry.fromObject(obj.checkType);
+    const extendsType = SchemaRegistry.fromObject(obj.extendsType);
+    const trueType = SchemaRegistry.fromObject(obj.trueType);
+    const falseType = SchemaRegistry.fromObject(obj.falseType);
+    return new ConditionalTypeSchema(location, checkType, extendsType, trueType, falseType);
+  }
+}

package/schemas/constructor.ts

@@ -0,0 +1,28 @@
+import { SchemaLocation } from '../schema-node';
+import { ParameterSchema } from './parameter';
+import { FunctionLikeSchema, Modifier } from './function-like';
+import { DocSchema } from './docs';
+import { ThisTypeSchema } from './this-type';
+
+export class ConstructorSchema extends FunctionLikeSchema {
+  constructor(
+    location: SchemaLocation,
+    params: ParameterSchema[],
+    returnType: ThisTypeSchema,
+    signature: string,
+    modifiers: Modifier[] = [],
+    doc?: DocSchema
+  ) {
+    super(location, 'constructor', params, returnType, signature, modifiers, doc, undefined);
+  }
+
+  static fromObject(obj: Record<string, any>): ConstructorSchema {
+    const location = obj.location;
+    const params = obj.params.map((param: any) => ParameterSchema.fromObject(param));
+    const returns = ThisTypeSchema.fromObject(obj.returnType);
+    const signature = obj.signature;
+    const modifiers = obj.modifiers;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new ConstructorSchema(location, params, returns, signature, modifiers, doc);
+  }
+}

package/schemas/decorator.ts

@@ -0,0 +1,54 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+import { DocSchema } from './docs';
+
+export class DecoratorSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly doc?: DocSchema,
+    readonly args?: SchemaNode[]
+  ) {
+    super();
+  }
+
+  getNodes() {
+    return this.args || [];
+  }
+
+  toString() {
+    const argsStr = this.args?.map((arg) => arg.toString()).join(', ');
+    return `@${this.name}${argsStr ? `(${argsStr})` : ''}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    const argsStr = this.args?.map((arg) => arg.toFullSignature(options)).join(', ');
+
+    result += `@${this.name}${argsStr ? `(${argsStr})` : ''}`;
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      doc: this.doc?.toObject(),
+      args: this.args?.map((arg) => arg.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): DecoratorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const args = obj.args ? obj.args.map((arg) => SchemaRegistry.fromObject(arg)) : undefined;
+    return new DecoratorSchema(location, name, doc, args);
+  }
+}

package/schemas/docs/doc.ts

@@ -0,0 +1,69 @@
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
+import { TagName, TagSchema } from './tag';
+
+export class DocSchema extends SchemaNode {
+  readonly tags?: TagSchema[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly raw: string,
+    readonly comment?: string,
+    tags?: TagSchema[]
+  ) {
+    super();
+    this.tags = tags;
+  }
+
+  toString() {
+    const comment = this.comment ? `${this.comment}\n` : '';
+    const tags = this.tags ? this.tags.map((tag) => tag.toString()).join('\n') : '';
+    return `${comment}${tags}`;
+  }
+
+  toFullSignature(): string {
+    const lines: string[] = [];
+
+    if (this.comment) {
+      lines.push(...this.comment.split('\n').map((line) => ` * ${line.trim()}`));
+    }
+
+    if (this.tags && this.tags.length > 0) {
+      for (const tag of this.tags) {
+        lines.push(` * ${tag.toString().trim()}`);
+      }
+    }
+
+    if (lines.length === 0) {
+      return '';
+    }
+
+    return `/**\n${lines.join('\n')}\n */`;
+  }
+
+  hasTag(tagName: TagName) {
+    return Boolean(this.findTag(tagName));
+  }
+
+  findTag(tagName: TagName) {
+    return this.tags?.find((tag) => tag.tagName === tagName);
+  }
+
+  toObject() {
+    return {
+      __schema: this.__schema,
+      name: this.name,
+      location: this.location,
+      signature: this.signature,
+      raw: this.raw,
+      comment: this.comment,
+      tags: this.tags ? this.tags.map((tag) => tag.toObject()) : undefined,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): DocSchema {
+    const location = obj.location;
+    const tags = obj.tags ? obj.tags.map((tag: any) => SchemaRegistry.fromObject(tag)) : undefined;
+    return new DocSchema(location, obj.raw, obj.comment, tags);
+  }
+}

package/schemas/docs/index.ts

@@ -0,0 +1,4 @@
+export { DocSchema } from './doc';
+export { TagSchema } from './tag';
+export { ReturnTagSchema } from './return-tag';
+export { PropertyLikeTagSchema } from './property-like-tag';

package/schemas/docs/property-like-tag.ts

@@ -0,0 +1,47 @@
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
+import { TagName, TagSchema } from './tag';
+
+/**
+ * e.g. `@param myParam {string} some comment`
+ */
+export class PropertyLikeTagSchema extends TagSchema {
+  readonly type?: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly comment?: string,
+    type?: SchemaNode
+  ) {
+    super(location, TagName.parameter, comment);
+    this.type = type;
+  }
+
+  toString() {
+    const comment = this.comment ? ` ${this.comment}` : '';
+    const type = this.type ? ` {${this.type.toString()}} ` : '';
+    return `@${this.tagName} ${this.name}${type} ${comment}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeStr = this.type ? ` {${this.type.toFullSignature(options)}} ` : '';
+    const comment = this.comment ? ` ${this.comment}` : '';
+    return `@${this.tagName} ${this.name}${typeStr}${comment}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): PropertyLikeTagSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const comment = obj.comment;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    return new PropertyLikeTagSchema(location, name, comment, type);
+  }
+}

package/schemas/docs/return-tag.ts

@@ -0,0 +1,44 @@
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
+import { TagName, TagSchema } from './tag';
+
+/**
+ * e.g. `@return {string} some comment`
+ */
+export class ReturnTagSchema extends TagSchema {
+  readonly type?: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly comment?: string,
+    type?: SchemaNode
+  ) {
+    super(location, TagName.return, comment);
+    this.type = type;
+  }
+
+  toString() {
+    const comment = this.comment ? ` ${this.comment}` : '';
+    return `@${this.tagName}${comment}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeStr = this.type ? ` {${this.type.toFullSignature(options)}}` : '';
+    const comment = this.comment ? ` ${this.comment}` : '';
+    return `@${this.tagName}${typeStr}${comment}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ReturnTagSchema {
+    const location = obj.location;
+    const comment = obj.comment;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    return new ReturnTagSchema(location, comment, type);
+  }
+}

package/schemas/docs/tag.ts

@@ -0,0 +1,66 @@
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+
+/**
+ * e.g. `@deprecated please use something else`
+ */
+export class TagSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly tagName: TagName | string,
+    readonly comment?: string
+  ) {
+    super();
+  }
+
+  toString() {
+    const comment = this.comment ? ` ${this.comment}` : '';
+    return `@${this.tagName}${comment}`;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  static fromObject(obj: Record<string, any>): TagSchema {
+    const location = obj.location;
+    const tagName = obj.tagName;
+    const comment = obj.comment;
+    return new TagSchema(location, tagName, comment);
+  }
+
+  toObject() {
+    return {
+      __schema: this.__schema,
+      location: this.location,
+      name: this.name,
+      signature: this.signature,
+      tagName: this.tagName,
+      comment: this.comment,
+    };
+  }
+}
+
+export enum TagName {
+  augments = 'augments',
+  author = 'author',
+  class = 'class',
+  callback = 'callback',
+  public = 'public',
+  private = 'private',
+  protected = 'protected',
+  readonly = 'readonly',
+  override = 'override',
+  see = 'see',
+  enum = 'enum',
+  parameter = 'parameter',
+  this = 'this',
+  type = 'type',
+  template = 'template',
+  typedef = 'typedef',
+  property = 'property',
+  implements = 'implements',
+  return = 'return',
+  deprecated = 'deprecated',
+  exports = 'exports',
+  link = 'link',
+}

package/schemas/enum-member.ts

@@ -0,0 +1,57 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+
+export class EnumMemberSchema extends SchemaNode {
+  readonly doc?: DocSchema;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly signature: string,
+    readonly value?: string,
+    doc?: DocSchema
+  ) {
+    super();
+    this.doc = doc;
+  }
+
+  toString() {
+    if (!this.value) return this.name;
+    return `${this.name}=${this.value}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    if (this.value !== undefined) {
+      result += `${this.name} = ${this.value}`;
+    } else {
+      result += `${this.name}`;
+    }
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      signature: this.signature,
+      value: this.value,
+      doc: this.doc?.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): EnumMemberSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const signature = obj.signature;
+    const value = obj.value;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new EnumMemberSchema(location, name, signature, value, doc);
+  }
+}

package/schemas/enum.ts

@@ -0,0 +1,73 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+import { SchemaRegistry } from '..';
+
+export class EnumSchema extends SchemaNode {
+  readonly doc?: DocSchema;
+  readonly members: SchemaNode[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    members: SchemaNode[],
+    readonly signature: string,
+    doc?: DocSchema
+  ) {
+    super();
+    this.doc = doc;
+    this.members = members;
+  }
+
+  getNodes() {
+    return this.members;
+  }
+
+  toString(options) {
+    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`;
+    }
+
+    result += `enum ${this.name} {\n`;
+
+    const membersStr = this.members
+      .map((member) => {
+        const memberStr = member.toFullSignature(options);
+        return `  ${memberStr}`;
+      })
+      .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,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): EnumSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const members = obj.members.map((member: any) => SchemaRegistry.fromObject(member));
+    const signature = obj.signature;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new EnumSchema(location, name, members, signature, doc);
+  }
+}