@teambit/semantics.entities.semantic-schema 0.0.9 → 0.0.12

package/schemas/function-like.ts

@@ -0,0 +1,56 @@
+import { Transform } from 'class-transformer';
+import chalk from 'chalk';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances, schemaObjToInstance } from '../schema-obj-to-class';
+import { ParameterSchema } from './parameter';
+
+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 {
+  @Transform(schemaObjToInstance)
+  readonly returnType: SchemaNode;
+
+  @Transform(schemaObjArrayToInstances)
+  readonly params: ParameterSchema[];
+
+  constructor(
+    readonly location: Location,
+    readonly name: string,
+    // readonly doc: any,
+    params: ParameterSchema[],
+
+    returnType: SchemaNode,
+    readonly signature: string,
+    readonly modifiers: Modifier[] = []
+  ) {
+    super();
+    this.params = params;
+    this.returnType = returnType;
+  }
+
+  getSignature() {
+    return this.signature;
+  }
+
+  toString() {
+    const paramsStr = this.params.map((param) => param.toString()).join(', ');
+    return `${this.modifiersToString()}${chalk.bold(this.name)}(${paramsStr}): ${this.returnType.toString()}`;
+  }
+
+  private modifiersToString() {
+    const modifiersToPrint = this.modifiers.filter((modifier) => modifier !== 'export');
+    return modifiersToPrint.length ? `${modifiersToPrint.join(' ')} ` : '';
+  }
+}

package/schemas/get-accessor.ts

@@ -1,21 +1,19 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class GetAccessorSchema implements SchemaNode {
-  constructor(private name: string, private type: SchemaNode, private signature: string) {}
+export class GetAccessorSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, readonly name: string, type: SchemaNode, readonly signature: string) {
+    super();
+    this.type = type;
+  }
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      type: this.type.toObject(),
-      signature: this.signature,
-    };
-  }
-
   toString() {
     return `get ${chalk.bold(this.name)}(): ${this.type.toString()}`;
   }

package/schemas/index-signature.ts

@@ -1,19 +1,23 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
+import { schemaObjArrayToInstances, schemaObjToInstance } from '../schema-obj-to-class';
 
 /**
  * e.g. `{ [key: string]: boolean };`
  * the "[key: string]" is the "parameter", and the "boolean" is the "type".
  */
-export class IndexSignatureSchema implements SchemaNode {
-  constructor(private params: ParameterSchema[], private type: SchemaNode) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      parameters: this.params,
-      type: this.type.toObject(),
-    };
+export class IndexSignatureSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly params: ParameterSchema[];
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, params: ParameterSchema[], type: SchemaNode) {
+    super();
+    this.params = params;
+    this.type = type;
   }
+
   toString() {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     return `[${paramsStr}]: ${this.type.toString()}`;

package/schemas/index.ts

@@ -1,6 +1,5 @@
 export { Module } from './module';
-export { Export, StaticProperties } from './export';
-export { FunctionSchema, Modifier } from './function';
+export { FunctionLikeSchema, Modifier } from './function-like';
 export { TypeRefSchema } from './type-ref';
 export { VariableSchema } from './variable';
 export { ClassSchema } from './class';
@@ -21,3 +20,7 @@ export { TypeArraySchema } from './type-array';
 export { TypeOperatorSchema } from './type-operator';
 export { TupleTypeSchema } from './tuple-type';
 export { ParameterSchema } from './parameter';
+export { EnumSchema } from './enum';
+export { ParenthesizedTypeSchema } from './parenthesized-type';
+export { TypePredicateSchema } from './type-predicate';
+export { IndexedAccessSchema } from './indexed-access-type';

package/schemas/indexed-access-type.ts

@@ -0,0 +1,18 @@
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
+
+export class IndexedAccessSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly objectType: SchemaNode;
+  @Transform(schemaObjToInstance)
+  readonly indexType: SchemaNode;
+  constructor(readonly location: Location, objectType: SchemaNode, indexType: SchemaNode) {
+    super();
+    this.objectType = objectType;
+    this.indexType = indexType;
+  }
+  toString() {
+    return `${this.objectType.toString()}[${this.indexType.toString()}]`;
+  }
+}

package/schemas/inference-type.ts

@@ -1,19 +1,17 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * where there is no explicit type, the type is taken from the "quickinfo" of tsserver
  */
-export class InferenceTypeSchema implements SchemaNode {
-  constructor(private type: string) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      type: this.type,
-    };
+export class InferenceTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, readonly type: string, readonly name?: string) {
+    super();
   }
 
   toString() {
+    if (this.name) {
+      return `${this.name}: ${this.type}`;
+    }
     return this.type;
   }
 }

package/schemas/interface.ts

@@ -1,15 +1,16 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class InterfaceSchema implements SchemaNode {
-  constructor(private name: string, private members: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      types: this.members.map((type) => type.toObject()),
-    };
+export class InterfaceSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly members: SchemaNode[];
+  constructor(readonly location: Location, readonly name: string, members: SchemaNode[]) {
+    super();
+    this.members = members;
   }
+
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.name)}\n${membersStr}`;

package/schemas/keyword-type.ts

@@ -1,16 +1,11 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * e.g. 'string', 'boolean', etc.
  */
-export class KeywordTypeSchema implements SchemaNode {
-  constructor(private name: string) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-    };
+export class KeywordTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, private name: string) {
+    super();
   }
 
   toString() {

package/schemas/literal-type.ts

@@ -1,10 +1,12 @@
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 
 /**
  * e.g. const a: 'a';
  */
-export class LiteralTypeSchema implements SchemaNode {
-  constructor(private name: string) {}
+export class LiteralTypeSchema extends SchemaNode {
+  constructor(readonly location: Location, readonly name: string) {
+    super();
+  }
 
   toObject() {
     return {

package/schemas/module.ts

@@ -1,13 +1,15 @@
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
-import { Export } from '../schemas';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class Module implements SchemaNode {
+export class Module extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  exports: SchemaNode[];
   namespace?: string;
-  constructor(public exports: SchemaNode[]) {}
-
-  getExportSchemas(): Export[] {
-    return this.exports.filter((e) => e instanceof Export) as Export[];
+  constructor(readonly location: Location, exports: SchemaNode[]) {
+    super();
+    this.exports = exports;
   }
 
   toObject() {

package/schemas/parameter.ts

@@ -1,22 +1,21 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class ParameterSchema implements SchemaNode {
+export class ParameterSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
   constructor(
+    readonly location: Location,
     readonly name: string,
-    readonly type: SchemaNode,
+    type: SchemaNode,
     readonly defaultValue?: any,
     readonly description?: string
-  ) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      type: this.type.toObject(),
-      defaultValue: this.defaultValue,
-      description: this.description,
-    };
+  ) {
+    super();
+    this.type = type;
   }
+
   toString() {
     return `${this.name}: ${this.type.toString()}`;
   }

package/schemas/parenthesized-type.ts

@@ -0,0 +1,20 @@
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
+
+/**
+ * type inside parentheses
+ * e.g. (T1 | T2)
+ */
+export class ParenthesizedTypeSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, type: SchemaNode) {
+    super();
+    this.type = type;
+  }
+
+  toString() {
+    return `(${this.type.toString()})`;
+  }
+}

package/schemas/set-accessor.ts

@@ -1,22 +1,20 @@
+import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class SetAccessorSchema implements SchemaNode {
-  constructor(private name: string, private param: ParameterSchema, private signature: string) {}
+export class SetAccessorSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly param: ParameterSchema;
+  constructor(readonly location: Location, readonly name: string, param: ParameterSchema, readonly signature: string) {
+    super();
+    this.param = param;
+  }
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      param: this.param,
-      signature: this.signature,
-    };
-  }
-
   toString() {
     return `set ${chalk.bold(this.name)}(${this.param.toString()})`;
   }

package/schemas/tuple-type.ts

@@ -1,13 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class TupleTypeSchema implements SchemaNode {
-  constructor(private elements: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      elements: this.elements.map((elem) => elem.toObject()),
-    };
+export class TupleTypeSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly elements: SchemaNode[];
+  constructor(readonly location: Location, elements: SchemaNode[]) {
+    super();
+    this.elements = elements;
   }
+
   toString() {
     return `[${this.elements.map((elem) => elem.toString()).join(', ')}]`;
   }

package/schemas/type-array.ts

@@ -1,13 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class TypeArraySchema implements SchemaNode {
-  constructor(private type: SchemaNode) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      type: this.type.toObject(),
-    };
+export class TypeArraySchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, type: SchemaNode) {
+    super();
+    this.type = type;
   }
+
   toString() {
     return `${this.type.toString()}[]`;
   }

package/schemas/type-intersection.ts

@@ -1,13 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
-export class TypeIntersectionSchema implements SchemaNode {
-  constructor(private types: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      types: this.types.map((type) => type.toObject()),
-    };
+export class TypeIntersectionSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly types: SchemaNode[];
+  constructor(readonly location: Location, types: SchemaNode[]) {
+    super();
+    this.types = types;
   }
+
   toString() {
     return `${this.types.map((type) => type.toString()).join(' & ')}`;
   }

package/schemas/type-literal.ts

@@ -1,16 +1,18 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
 /**
  * e.g. `{ a: string; b: number }`
  */
-export class TypeLiteralSchema implements SchemaNode {
-  constructor(private members: SchemaNode[]) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      types: this.members.map((type) => type.toObject()),
-    };
+export class TypeLiteralSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  readonly members: SchemaNode[];
+  constructor(readonly location: Location, members: SchemaNode[]) {
+    super();
+    this.members = members;
   }
+
   toString() {
     return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;
   }

package/schemas/type-operator.ts

@@ -1,14 +1,15 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
-export class TypeOperatorSchema implements SchemaNode {
-  constructor(private operatorName: string, private type: SchemaNode) {}
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      operatorName: this.operatorName,
-      type: this.type.toObject(),
-    };
+export class TypeOperatorSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  type: SchemaNode;
+  constructor(readonly location: Location, readonly operatorName: string, type: SchemaNode) {
+    super();
+    this.type = type;
   }
+
   toString() {
     return `${this.operatorName} ${this.type.toString()}`;
   }

package/schemas/type-predicate.ts

@@ -0,0 +1,36 @@
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
+
+/**
+ * e.g. `function f(str: any): str is string {}`
+ *
+ * example when the type is empty:
+ * ```ts
+ * function assert(condition: any, msg?: string): asserts condition {
+ *  if (!condition) {
+ *   throw new AssertionError(msg);
+ *  }
+ * }
+ * ```
+ *
+ */
+export class TypePredicateSchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type?: SchemaNode;
+  constructor(
+    readonly location: Location,
+    readonly parameterName: string,
+    type?: SchemaNode,
+    readonly hasAssertsModifier = false
+  ) {
+    super();
+    this.type = type;
+  }
+
+  toString() {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeStr = this.type ? ` is ${this.type.toString()}` : '';
+    return assertsKeyword + this.parameterName + typeStr;
+  }
+}

package/schemas/type-query.ts

@@ -1,22 +1,21 @@
-import { SchemaNode } from '../schema-node';
+import { Transform } from 'class-transformer';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjToInstance } from '../schema-obj-to-class';
 
 /**
  * e.g. `typeof Foo`
  */
-export class TypeQuerySchema implements SchemaNode {
-  constructor(private type: SchemaNode, private signature: string) {}
+export class TypeQuerySchema extends SchemaNode {
+  @Transform(schemaObjToInstance)
+  readonly type: SchemaNode;
+  constructor(readonly location: Location, type: SchemaNode, readonly signature: string) {
+    super();
+    this.type = type;
+  }
   getSignature() {
     return this.signature;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      type: this.type,
-      signature: this.signature,
-    };
-  }
-
   toString() {
     return `typeof ${this.type.toString()}`;
   }

package/schemas/type-ref.ts

@@ -1,6 +1,8 @@
+import { Transform } from 'class-transformer';
 import { ComponentID } from '@teambit/component';
 import chalk from 'chalk';
-import { SchemaNode } from '../schema-node';
+import { Location, SchemaNode } from '../schema-node';
+import { schemaObjArrayToInstances } from '../schema-obj-to-class';
 
 export type PlainTypeRefSchema = {
   name: string;
@@ -8,8 +10,21 @@ export type PlainTypeRefSchema = {
   packageName?: string;
 };
 
-export class TypeRefSchema implements SchemaNode {
+/**
+ * can be one of the following:
+ * 1. a reference to another "export" in the same component
+ * 2. a reference to another component.
+ * 3. a reference to a package.
+ */
+export class TypeRefSchema extends SchemaNode {
+  @Transform(schemaObjArrayToInstances)
+  /**
+   *  optional type arguments, e.g. type Foo = Bar<X, Y>. The X and Y are type arguments.
+   */
+  typeArgs?: SchemaNode[];
+
   constructor(
+    readonly location: Location,
     /**
      * name of the reference to type.
      */
@@ -24,23 +39,27 @@ export class TypeRefSchema implements SchemaNode {
      * target package name. existing if type is defined in different package.
      */
     readonly packageName?: string
-  ) {}
-
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      name: this.name,
-      componentId: this.componentId,
-      packageName: this.packageName,
-    };
+  ) {
+    super();
   }
 
   toString() {
+    const name = this.nameToString();
+    if (!this.typeArgs) {
+      return name;
+    }
+    const args = this.typeArgs.map((arg) => arg.toString()).join(', ');
+    return `${name}<${args}>`;
+  }
+
+  private nameToString() {
     if (this.componentId) {
-      return `${this.componentId}/${this.name}`;
+      const compStr = chalk.dim(`(component: ${this.componentId.toStringWithoutVersion()})`);
+      return `${compStr} ${this.name}`;
     }
     if (this.packageName) {
-      return `${chalk.dim(this.packageName)}/${this.name}`;
+      const pkgStr = chalk.dim(`(package: ${this.packageName})`);
+      return `${pkgStr} ${this.name}`;
     }
     return this.name;
   }
@@ -52,11 +71,11 @@ export class TypeRefSchema implements SchemaNode {
     return !this.componentId && !this.packageName;
   }
 
-  static from(plainSchema: PlainTypeRefSchema) {
-    return new TypeRefSchema(
-      plainSchema.name,
-      plainSchema.componentId ? ComponentID.fromString(plainSchema.componentId) : undefined,
-      plainSchema.packageName
-    );
-  }
+  // static from(plainSchema: PlainTypeRefSchema) {
+  //   return new TypeRefSchema(
+  //     plainSchema.name,
+  //     plainSchema.componentId ? ComponentID.fromString(plainSchema.componentId) : undefined,
+  //     plainSchema.packageName
+  //   );
+  // }
 }