@teambit/semantics.entities.semantic-schema 0.0.69 → 0.0.71

package/schemas/docs/doc.ts

@@ -16,6 +16,26 @@ export class DocSchema extends SchemaNode {
     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));
   }

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

@@ -18,6 +18,12 @@ export class PropertyLikeTagSchema extends TagSchema {
     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(),

package/schemas/docs/return-tag.ts

@@ -18,6 +18,12 @@ export class ReturnTagSchema extends TagSchema {
     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(),

package/schemas/docs/tag.ts

@@ -13,6 +13,10 @@ export class TagSchema extends SchemaNode {
     return `@${this.tagName}${comment}`;
   }
 
+  toFullSignature(): string {
+    return this.toString();
+  }
+
   static fromObject(obj: Record<string, any>): TagSchema {
     const location = obj.location;
     const tagName = obj.tagName;
@@ -54,4 +58,5 @@ export enum TagName {
   return = 'return',
   deprecated = 'deprecated',
   exports = 'exports',
+  link = 'link',
 }

package/schemas/enum-member.ts

@@ -20,6 +20,22 @@ export class EnumMemberSchema extends SchemaNode {
     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(),

package/schemas/enum.ts

@@ -23,9 +23,33 @@ export class EnumSchema extends SchemaNode {
     return this.members;
   }
 
-  toString() {
-    const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
-    return `${chalk.bold.underline(this.name)}\n${membersStr}`;
+  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() {

package/schemas/export.ts

@@ -6,6 +6,7 @@ export class ExportSchema extends SchemaNode {
   alias?: string;
   exportNode: SchemaNode;
   readonly doc?: DocSchema;
+  readonly signature?: string;
 
   constructor(
     readonly location: SchemaLocation,
@@ -18,13 +19,50 @@ export class ExportSchema extends SchemaNode {
     this.exportNode = exportNode;
     this.alias = alias;
     this.doc = doc;
+    this.signature = exportNode.signature || this.toFullSignature();
   }
 
-  toString() {
-    if (this.alias) {
-      return `${this.name} as ${this.alias}`;
+  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`;
     }
-    return `${this.name}`;
+
+    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() {

package/schemas/expression-with-arguments.ts

@@ -20,6 +20,17 @@ export class ExpressionWithTypeArgumentsSchema extends SchemaNode {
     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(),

package/schemas/function-like.ts

@@ -47,13 +47,46 @@ export class FunctionLikeSchema extends SchemaNode {
     return [...this.params, this.returnType, ...(this.decorators || [])];
   }
 
-  toString() {
+  toString({ color }) {
+    const bold = 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()).join('\n');
-    return `${this.decorators ? `${decoratorsStr}\n` : ''}${this.modifiersToString()}${typeParamsStr}${chalk.bold(
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString({ color })).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${this.modifiersToString()}${typeParamsStr}${bold(
       this.name
-    )}(${paramsStr}): ${this.returnType.toString()}`;
+    )}(${paramsStr}): ${this.returnType.toString({ color })}`;
+  }
+
+  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 {

package/schemas/get-accessor.ts

@@ -16,8 +16,21 @@ export class GetAccessorSchema extends SchemaNode {
     return [this.type];
   }
 
-  toString() {
-    return `get ${chalk.bold(this.name)}(): ${this.type.toString()}`;
+  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() {

package/schemas/ignored.ts

@@ -25,6 +25,10 @@ export class IgnoredSchema extends SchemaNode {
     return '';
   }
 
+  toFullSignature(): string {
+    return '';
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/index-signature.ts

@@ -20,6 +20,13 @@ export class IndexSignatureSchema extends SchemaNode {
     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(),

package/schemas/indexed-access-type.ts

@@ -19,6 +19,13 @@ export class IndexedAccessSchema extends SchemaNode {
     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(),

package/schemas/inference-type.ts

@@ -9,7 +9,8 @@ export class InferenceTypeSchema extends SchemaNode {
     readonly type: string,
     readonly name?: string,
     readonly defaultValue?: string,
-    readonly isSpread?: boolean
+    readonly isSpread?: boolean,
+    readonly alias?: string
   ) {
     super();
   }
@@ -21,12 +22,29 @@ export class InferenceTypeSchema extends SchemaNode {
     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,
     };
   }
 
@@ -36,6 +54,7 @@ export class InferenceTypeSchema extends SchemaNode {
     const name = obj.name;
     const defaultValue = obj.defaultValue;
     const isSpread = obj.isSpread;
-    return new InferenceTypeSchema(location, type, name, defaultValue, isSpread);
+    const alias = obj.alias;
+    return new InferenceTypeSchema(location, type, name, defaultValue, isSpread, alias);
   }
 }

package/schemas/interface.ts

@@ -26,9 +26,47 @@ export class InterfaceSchema extends SchemaNode {
     return this.members;
   }
 
-  toString() {
-    const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
-    return `${chalk.bold.underline(this.name)}\n${membersStr}`;
+  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() {

package/schemas/keyword-type.ts

@@ -12,6 +12,10 @@ export class KeywordTypeSchema extends SchemaNode {
     return this.name;
   }
 
+  toFullSignature(): string {
+    return this.toString();
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/literal-type.ts

@@ -19,6 +19,10 @@ export class LiteralTypeSchema extends SchemaNode {
     return this.name;
   }
 
+  toFullSignature(): string {
+    return this.toString();
+  }
+
   static fromObject(obj: Record<string, any>): LiteralTypeSchema {
     const location = obj.location;
     const name = obj.name;

package/schemas/literal-value.ts

@@ -10,6 +10,10 @@ export class LiteralValueSchema extends SchemaNode {
     return this.value;
   }
 
+  toFullSignature(): string {
+    return this.toString();
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/module.ts

@@ -5,11 +5,11 @@ import { ExportSchema } from './export';
 
 export class ModuleSchema extends SchemaNode {
   // exports could either be re exports (export declarations) or nodes with export modifier
-  exports: (ExportSchema | SchemaNode)[];
+  exports: SchemaNode[];
   internals: SchemaNode[];
   namespace?: string;
 
-  constructor(readonly location: SchemaLocation, exports: (ExportSchema | SchemaNode)[], internals: SchemaNode[]) {
+  constructor(readonly location: SchemaLocation, exports: SchemaNode[], internals: SchemaNode[]) {
     super();
     this.exports = exports;
     this.internals = internals;
@@ -30,13 +30,33 @@ export class ModuleSchema extends SchemaNode {
     }, [] as (ExportSchema | SchemaNode)[]);
   }
 
-  toString() {
+  toString(options?: { color?: boolean }) {
     if (!this.namespace)
       throw new Error(
         'toString() should not be called on a module without namespace, make sure this.flatExportsRecursively() is called'
       );
-    const exportsStr = this.exports.map((m) => `* ${m.toString()}`).join('\n');
-    return `${chalk.bold.underline(this.namespace)}\n${exportsStr}`;
+    const boldUnderline = options?.color ? chalk.bold.underline : (str: string) => str;
+
+    const exportsStr = this.exports.map((m) => `* ${m.toString(options)}`).join('\n');
+    return `${boldUnderline(this.namespace)}\n${exportsStr}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    if (!this.namespace)
+      throw new Error(
+        'toFullSignature() should not be called on a module without namespace; make sure this.flatExportsRecursively() is called'
+      );
+
+    const exportsSignatures = this.exports.map((m) => m.toFullSignature(options)).join('\n');
+
+    let signature = `${this.namespace}\n${exportsSignatures}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
   }
 
   toObject() {

package/schemas/named-tuple.ts

@@ -10,8 +10,12 @@ export class NamedTupleSchema extends SchemaNode {
     return [this.type];
   }
 
-  toString() {
-    return `${this.name}: ${this.type.toString()}`;
+  toString(options?: { color?: boolean }): string {
+    return `${this.name}: ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `${this.name}: ${this.type.toFullSignature(options)}`;
   }
 
   toObject() {

package/schemas/object-literal-expression.ts

@@ -10,8 +10,17 @@ export class ObjectLiteralExpressionSchema extends SchemaNode {
     return this.members;
   }
 
-  toString(): string {
-    return `{\n${this.members.map((member) => `\t${member.toString()}`).join('\n')}\n}`;
+  toString(options?: { color?: boolean }): string {
+    return `{\n${this.members.map((member) => `\t${member.toString(options)}`).join('\n')}\n}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const membersStr = this.members.map((member) => member.toFullSignature(options)).join(',\n');
+
+    return `{\n${membersStr
+      .split('\n')
+      .map((line) => `  ${line}`)
+      .join('\n')}\n}`;
   }
 
   toObject() {

package/schemas/parameter.ts

@@ -25,6 +25,46 @@ export class ParameterSchema<T extends SchemaNode = SchemaNode> extends SchemaNo
     return `${this.name}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
   }
 
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let paramStr = '';
+
+    if (options?.showDocs && this.description) {
+      paramStr += `/** ${this.description} */\n`;
+    }
+
+    if (this.isSpread) {
+      paramStr += '...';
+    }
+
+    let paramName = '';
+
+    if (this.objectBindingNodes && this.objectBindingNodes.length > 0) {
+      const bindingsStr = this.objectBindingNodes.map((node) => node.toFullSignature(options)).join(', ');
+      paramName += `{ ${bindingsStr} }`;
+    } else {
+      paramName += this.name;
+    }
+
+    if (this.isOptional) {
+      paramName += '?';
+    }
+
+    paramStr += `${paramName}`;
+
+    if (this.type && typeof this.type.toString === 'function') {
+      const typeName = this.type.toString();
+      if (typeName) {
+        paramStr += `: ${typeName}`;
+      }
+    }
+
+    if (this.defaultValue !== undefined) {
+      paramStr += ` = ${this.defaultValue}`;
+    }
+
+    return paramStr;
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/parenthesized-type.ts

@@ -16,8 +16,12 @@ export class ParenthesizedTypeSchema extends SchemaNode {
     return [this.type];
   }
 
-  toString() {
-    return `(${this.type.toString()})`;
+  toString(options?: { color?: boolean }): string {
+    return `(${this.type.toString(options)})`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `(${this.type.toFullSignature(options)})`;
   }
 
   toObject() {

package/schemas/property-assignment.ts

@@ -12,8 +12,22 @@ export class PropertyAssignmentSchema extends SchemaNode {
     super();
   }
 
-  toString() {
-    return `${this.name}: ${this.value.toString()}`;
+  toString(options?: { color?: boolean }): string {
+    return `${this.name}: ${this.value.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    const valueStr = this.value.toFullSignature(options);
+
+    result += `${this.name}: ${valueStr}`;
+
+    return result;
   }
 
   toObject() {

package/schemas/set-accessor.ts

@@ -23,6 +23,11 @@ export class SetAccessorSchema extends SchemaNode {
     return `set ${chalk.bold(this.name)}(${this.param.toString()})`;
   }
 
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const paramStr = this.param.toFullSignature(options);
+    return `set ${this.name}(${paramStr})`;
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/template-literal-type-span.ts

@@ -13,8 +13,12 @@ export class TemplateLiteralTypeSpanSchema extends SchemaNode {
     return [this.type];
   }
 
-  toString() {
-    return `${this.type.toString()} ${this.literal}`;
+  toString(options?: { color?: boolean }) {
+    return `${this.type.toString(options)} ${this.literal}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `${this.type.toFullSignature(options)} ${this.literal}`;
   }
 
   toObject() {