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

package/schemas/type-intersection.ts

@@ -13,8 +13,12 @@ export class TypeIntersectionSchema extends SchemaNode {
     return this.types;
   }
 
-  toString() {
-    return `${this.types.map((type) => type.toString()).join(' & ')}`;
+  toString(options?: { color?: boolean }) {
+    return `${this.types.map((type) => type.toString(options)).join(' & ')}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return this.types.map((type) => type.toFullSignature(options)).join(' & ');
   }
 
   toObject() {

package/schemas/type-literal.ts

@@ -20,6 +20,28 @@ export class TypeLiteralSchema extends SchemaNode {
     return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;
   }
 
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const indent = (level: number) => '  '.repeat(level);
+    const level = 0;
+    let signature = '';
+
+    signature += '{\n';
+
+    this.members.forEach((member) => {
+      const memberSignature = member.toFullSignature(options);
+
+      const memberLines = memberSignature.split('\n');
+
+      const indentedLines = memberLines.map((line) => indent(level + 1) + line);
+
+      signature += indentedLines.join('\n') + '\n';
+    });
+
+    signature += indent(level) + '}';
+
+    return signature;
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/type-operator.ts

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

package/schemas/type-predicate.ts

@@ -26,12 +26,25 @@ export class TypePredicateSchema extends SchemaNode {
     this.type = type;
   }
 
-  toString() {
+  toString(options?: { color?: boolean }) {
     const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
-    const typeStr = this.type ? ` is ${this.type.toString()}` : '';
+    const typeStr = this.type ? ` is ${this.type.toString(options)}` : '';
     return assertsKeyword + this.name + typeStr;
   }
 
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeSignature = this.type ? ` is ${this.type.toFullSignature(options)}` : '';
+    let signature = `${assertsKeyword}${this.name}${typeSignature}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/type-query.ts

@@ -20,8 +20,12 @@ export class TypeQuerySchema extends SchemaNode {
     return this.signature;
   }
 
-  toString() {
-    return `typeof ${this.type.toString()}`;
+  toString(options?: { color?: boolean }) {
+    return `typeof ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `typeof ${this.type.toFullSignature(options)}`;
   }
 
   toObject() {

package/schemas/type-ref.ts

@@ -52,27 +52,44 @@ export class TypeRefSchema extends SchemaNode {
     return this;
   }
 
-  toString() {
-    const name = this.nameToString();
+  toString(options?: { color?: boolean }) {
+    const name = this.nameToString(options);
     if (!this.typeArgs) {
       return name;
     }
-    const args = this.typeArgs.map((arg) => arg.toString()).join(', ');
+    const args = this.typeArgs.map((arg) => arg.toString(options)).join(', ');
     return `${name}<${args}>`;
   }
 
-  private nameToString() {
+  private nameToString(options?: { color?: boolean }) {
+    const dim = options?.color ? chalk.dim : (str: string) => str;
     if (this.componentId) {
-      const compStr = chalk.dim(`(component: ${this.componentId.toStringWithoutVersion()})`);
+      const compStr = dim(`(component: ${this.componentId.toStringWithoutVersion()})`);
       return `${compStr} ${this.name}`;
     }
     if (this.packageName) {
-      const pkgStr = chalk.dim(`(package: ${this.packageName})`);
+      const pkgStr = dim(`(package: ${this.packageName})`);
       return `${pkgStr} ${this.name}`;
     }
     return this.name;
   }
 
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let signature = this.name;
+
+    if (this.typeArgs && this.typeArgs.length > 0) {
+      const argsSignatures = this.typeArgs.map((arg) => arg.toFullSignature(options)).join(', ');
+      signature += `<${argsSignatures}>`;
+    }
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
   /**
    * whether this type was already exported in this component
    */

package/schemas/type-union.ts

@@ -7,8 +7,19 @@ export class TypeUnionSchema extends SchemaNode {
     super();
     this.types = types;
   }
-  toString() {
-    return `${this.types.map((type) => type.toString()).join(' | ')}`;
+  toString(options?: { color?: boolean }) {
+    return `${this.types.map((type) => type.toString(options)).join(' | ')}`;
+  }
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeSignatures = this.types.map((type) => type.toFullSignature(options));
+    let signature = typeSignatures.join(' | ');
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
   }
   getNodes() {
     return this.types;

package/schemas/type.ts

@@ -19,8 +19,22 @@ export class TypeSchema extends SchemaNode {
     this.doc = doc;
   }
 
-  toString() {
-    return `${chalk.bold(this.name)}: ${this.type.toString()}`;
+  toString(options?: { color?: boolean }) {
+    const bold = options?.color ? chalk.bold : (str: string) => str;
+    return `${bold(this.name)}: ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeSignature = this.type.toFullSignature(options);
+
+    let signature = `${this.name}: ${typeSignature}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
   }
 
   getNodes() {

package/schemas/unimplemented-schema.ts

@@ -9,6 +9,10 @@ export class UnImplementedSchema extends SchemaNode {
     return `<<unimplemented schema ${this.name} of type ${this.type}>>`;
   }
 
+  toFullSignature(): string {
+    return `<<unimplemented schema ${this.name} of type ${this.type}>>`;
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/unknown-schema.ts

@@ -14,6 +14,10 @@ export class UnknownSchema extends SchemaNode {
     return `<<unknown schema ${this.name}>>`;
   }
 
+  toFullSignature(): string {
+    return this.toString();
+  }
+
   toObject() {
     return {
       ...super.toObject(),

package/schemas/unresolved-schema.ts

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

package/schemas/variable-like.ts

@@ -28,8 +28,26 @@ export class VariableLikeSchema extends SchemaNode {
     return [this.type];
   }
 
-  toString() {
-    return `${chalk.bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
+  toString(options?: { color?: boolean }) {
+    const bold = options?.color ? chalk.bold : (str: string) => str;
+    return `${bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const namePart = `${this.name}${this.isOptional ? '?' : ''}`;
+    const typeSignature = this.type.toFullSignature(options);
+    let signature = `${namePart}: ${typeSignature}`;
+
+    if (this.defaultValue !== undefined) {
+      signature += ` = ${this.defaultValue}`;
+    }
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
   }
 
   toObject() {

package/dist/tsconfig.json

@@ -1,37 +0,0 @@
-{
-    "compilerOptions": {
-        "lib": [
-            "es2019",
-            "DOM",
-            "ES6",
-            "DOM.Iterable"
-        ],
-        "target": "es2015",
-        "module": "CommonJS",
-        "jsx": "react",
-        "allowJs": true,
-        "composite": true,
-        "declaration": true,
-        "sourceMap": true,
-        "skipLibCheck": true,
-        "experimentalDecorators": true,
-        "outDir": "dist",
-        "moduleResolution": "node",
-        "esModuleInterop": true,
-        "rootDir": ".",
-        "resolveJsonModule": true
-    },
-    "exclude": [
-        "artifacts",
-        "public",
-        "dist",
-        "node_modules",
-        "package.json",
-        "**/*.cjs"
-    ],
-    "include": [
-        "**/*",
-        "**/*.json"
-    ],
-    "references": []
-}

package/tsconfig.json

@@ -1,37 +0,0 @@
-{
-  "compilerOptions": {
-    "lib": [
-      "es2019",
-      "DOM",
-      "ES6",
-      "DOM.Iterable"
-    ],
-    "target": "es2015",
-    "module": "CommonJS",
-    "jsx": "react",
-    "allowJs": true,
-    "composite": true,
-    "declaration": true,
-    "sourceMap": true,
-    "skipLibCheck": true,
-    "experimentalDecorators": true,
-    "outDir": "dist",
-    "moduleResolution": "node",
-    "esModuleInterop": true,
-    "rootDir": ".",
-    "resolveJsonModule": true
-  },
-  "exclude": [
-    "artifacts",
-    "public",
-    "dist",
-    "node_modules",
-    "package.json",
-    "**/*.cjs"
-  ],
-  "include": [
-    "**/*",
-    "**/*.json"
-  ],
-  "references": []
-}