@teambit/semantics.entities.semantic-schema 0.0.51 → 0.0.54

package/schemas/docs/return-tag.ts

@@ -1,15 +1,14 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
+import { SchemaRegistry } from '../../schema-registry';
 import { TagName, TagSchema } from './tag';
-import { schemaObjToInstance } from '../../class-transformers';
 
 /**
  * e.g. `@return {string} some comment`
  */
 export class ReturnTagSchema extends TagSchema {
-  @Transform(schemaObjToInstance)
   readonly type?: SchemaNode;
-  constructor(readonly location: Location, readonly comment?: string, type?: SchemaNode) {
+
+  constructor(readonly location: SchemaLocation, readonly comment?: string, type?: SchemaNode) {
     super(location, TagName.return, comment);
     this.type = type;
   }
@@ -18,4 +17,18 @@ export class ReturnTagSchema extends TagSchema {
     const comment = this.comment ? ` ${this.comment}` : '';
     return `@${this.tagName}${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

@@ -1,10 +1,10 @@
-import { Location, SchemaNode } from '../../schema-node';
+import { SchemaLocation, SchemaNode } from '../../schema-node';
 
 /**
  * e.g. `@deprecated please use something else`
  */
 export class TagSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly tagName: TagName | string, readonly comment?: string) {
+  constructor(readonly location: SchemaLocation, readonly tagName: TagName | string, readonly comment?: string) {
     super();
   }
 
@@ -12,6 +12,24 @@ export class TagSchema extends SchemaNode {
     const comment = this.comment ? ` ${this.comment}` : '';
     return `@${this.tagName}${comment}`;
   }
+
+  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 {
@@ -35,4 +53,5 @@ export enum TagName {
   implements = 'implements',
   return = 'return',
   deprecated = 'deprecated',
+  exports = 'exports',
 }

package/schemas/enum-member.ts

@@ -1,14 +1,11 @@
-import { Transform } from 'class-transformer';
-import { schemaObjToInstance } from '../class-transformers';
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { DocSchema } from './docs';
 
 export class EnumMemberSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     readonly signature: string,
     readonly value?: string,
@@ -22,4 +19,23 @@ export class EnumMemberSchema extends SchemaNode {
     if (!this.value) return this.name;
     return `${this.name}=${this.value}`;
   }
+
+  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

@@ -1,17 +1,14 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { DocSchema } from './docs';
+import { SchemaRegistry } from '..';
 
 export class EnumSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
-  @Transform(schemaObjArrayToInstances)
   readonly members: SchemaNode[];
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     members: SchemaNode[],
     readonly signature: string,
@@ -22,8 +19,31 @@ export class EnumSchema extends SchemaNode {
     this.members = members;
   }
 
+  getNodes() {
+    return this.members;
+  }
+
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.name)}\n${membersStr}`;
   }
+
+  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);
+  }
 }

package/schemas/expression-with-arguments.ts

@@ -1,15 +1,16 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export class ExpressionWithTypeArgumentsSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly typeArgs: SchemaNode[];
-
-  @Transform(schemaObjToInstance)
   readonly expression: SchemaNode;
 
-  constructor(typeArgs: SchemaNode[], expression: SchemaNode, readonly name: string, readonly location: Location) {
+  constructor(
+    typeArgs: SchemaNode[],
+    expression: SchemaNode,
+    readonly name: string,
+    readonly location: SchemaLocation
+  ) {
     super();
     this.typeArgs = typeArgs;
     this.expression = expression;
@@ -18,4 +19,22 @@ export class ExpressionWithTypeArgumentsSchema extends SchemaNode {
   toString() {
     return this.name;
   }
+
+  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

@@ -1,10 +1,9 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
+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'
@@ -21,21 +20,17 @@ export type Modifier =
  * 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[];
-
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
+  readonly signature?: string | undefined;
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     params: ParameterSchema[],
     returnType: SchemaNode,
-    readonly signature: string,
+    signature: string,
     readonly modifiers: Modifier[] = [],
     doc?: DocSchema,
     readonly typeParams?: string[] // generics e.g. <T>myFunction
@@ -44,6 +39,11 @@ export class FunctionLikeSchema extends SchemaNode {
     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];
   }
 
   toString() {
@@ -62,6 +62,47 @@ export class FunctionLikeSchema extends SchemaNode {
     return Boolean(this.modifiers.find((m) => m === 'private') || this.doc?.hasTag(TagName.private));
   }
 
+  generateSignature(): string {
+    return FunctionLikeSchema.createSignature(this.name, this.params, this.returnType);
+  }
+
+  static createSignature(name: string, params: ParameterSchema[], returnType: SchemaNode): string {
+    const paramsStr = params
+      .map((param) => {
+        let type = param.type.toString();
+        if (param.isSpread) type = `...${type}`;
+        return `${param.name}${param.isOptional ? '?' : ''}: ${type}`;
+      })
+      .join(', ');
+    return `${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,
+    };
+  }
+
+  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
+    );
+  }
+
   private modifiersToString() {
     const modifiersToPrint = this.modifiers.filter((modifier) => modifier !== 'export');
     return modifiersToPrint.length ? `${modifiersToPrint.join(' ')} ` : '';

package/schemas/get-accessor.ts

@@ -1,12 +1,10 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjToInstance } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export class GetAccessorSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly type: SchemaNode;
-  constructor(readonly location: Location, readonly name: string, type: SchemaNode, readonly signature: string) {
+  constructor(readonly location: SchemaLocation, readonly name: string, type: SchemaNode, readonly signature: string) {
     super();
     this.type = type;
   }
@@ -14,7 +12,28 @@ export class GetAccessorSchema extends SchemaNode {
     return this.signature;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `get ${chalk.bold(this.name)}(): ${this.type.toString()}`;
   }
+
+  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/index-signature.ts

@@ -1,18 +1,15 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 import { ParameterSchema } from './parameter';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
 
 /**
  * e.g. `{ [key: string]: boolean };`
  * the "[key: string]" is the "parameter", and the "boolean" is the "type".
  */
 export class IndexSignatureSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly params: ParameterSchema[];
-  @Transform(schemaObjToInstance)
   readonly type: SchemaNode;
-  constructor(readonly location: Location, params: ParameterSchema[], type: SchemaNode) {
+  constructor(readonly location: SchemaLocation, params: ParameterSchema[], type: SchemaNode) {
     super();
     this.params = params;
     this.type = type;
@@ -22,4 +19,20 @@ export class IndexSignatureSchema extends SchemaNode {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     return `[${paramsStr}]: ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      location: this.location,
+      params: this.params.map((param) => param.toObject()),
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): IndexSignatureSchema {
+    const location = obj.location;
+    const params = obj.params.map((param: any) => ParameterSchema.fromObject(param));
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new IndexSignatureSchema(location, params, type);
+  }
 }

package/schemas/index.ts

@@ -4,7 +4,7 @@
  * and the schemaObjToClass can match and instantiate the Schema Class correctly
  */
 export { ModuleSchema } from './module';
-export { FunctionLikeSchema, Modifier } from './function-like';
+export { FunctionLikeSchema } from './function-like';
 export { TypeRefSchema } from './type-ref';
 export { VariableLikeSchema } from './variable-like';
 export { ClassSchema } from './class';

package/schemas/indexed-access-type.ts

@@ -1,18 +1,36 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjToInstance } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export class IndexedAccessSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly objectType: SchemaNode;
-  @Transform(schemaObjToInstance)
   readonly indexType: SchemaNode;
-  constructor(readonly location: Location, objectType: SchemaNode, 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()}]`;
   }
+
+  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

@@ -1,10 +1,15 @@
-import { Location, SchemaNode } from '../schema-node';
+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: Location, readonly type: string, readonly name?: string) {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly type: string,
+    readonly name?: string,
+    readonly defaultValue?: string
+  ) {
     super();
   }
 
@@ -14,4 +19,20 @@ export class InferenceTypeSchema extends SchemaNode {
     }
     return this.type;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type,
+      defaultValue: this.defaultValue,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): InferenceTypeSchema {
+    const location = obj.location;
+    const type = obj.type;
+    const name = obj.name;
+    const defaultValue = obj.defaultValue;
+    return new InferenceTypeSchema(location, type, name, defaultValue);
+  }
 }

package/schemas/interface.ts

@@ -1,19 +1,15 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances, schemaObjToInstance } from '../class-transformers';
+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 {
-  @Transform(schemaObjArrayToInstances)
   readonly members: SchemaNode[];
-
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     readonly signature: string,
     readonly extendsNodes: ExpressionWithTypeArgumentsSchema[],
@@ -26,8 +22,35 @@ export class InterfaceSchema extends SchemaNode {
     this.doc = doc;
   }
 
+  getNodes() {
+    return this.members;
+  }
+
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.name)}\n${membersStr}`;
   }
+
+  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);
+  }
 }

package/schemas/keyword-type.ts

@@ -1,14 +1,27 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 
 /**
  * e.g. 'string', 'boolean', etc.
  */
 export class KeywordTypeSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly name: string) {
+  constructor(readonly location: SchemaLocation, readonly name: string) {
     super();
   }
 
   toString() {
     return this.name;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): KeywordTypeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new KeywordTypeSchema(location, name);
+  }
 }

package/schemas/literal-type.ts

@@ -1,16 +1,16 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 
 /**
  * e.g. const a: 'a';
  */
 export class LiteralTypeSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly name: string) {
+  constructor(readonly location: SchemaLocation, readonly name: string) {
     super();
   }
 
   toObject() {
     return {
-      constructorName: this.constructor.name,
+      ...super.toObject(),
       name: this.name,
     };
   }
@@ -18,4 +18,10 @@ export class LiteralTypeSchema extends SchemaNode {
   toString() {
     return this.name;
   }
+
+  static fromObject(obj: Record<string, any>): LiteralTypeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new LiteralTypeSchema(location, name);
+  }
 }

package/schemas/module.ts

@@ -1,29 +1,20 @@
 import chalk from 'chalk';
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export class ModuleSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   exports: SchemaNode[];
-
-  @Transform(schemaObjArrayToInstances)
   internals: SchemaNode[];
-
   namespace?: string;
 
-  constructor(readonly location: Location, exports: SchemaNode[], internals: SchemaNode[]) {
+  constructor(readonly location: SchemaLocation, exports: SchemaNode[], internals: SchemaNode[]) {
     super();
     this.exports = exports;
     this.internals = internals;
   }
 
-  toObject() {
-    return {
-      constructorName: this.constructor.name,
-      namespace: this.namespace,
-      exports: this.exports.map((exp) => exp.toObject()),
-    };
+  getNodes() {
+    return [...this.exports, ...this.internals];
   }
 
   flatExportsRecursively() {
@@ -45,4 +36,23 @@ export class ModuleSchema extends SchemaNode {
     const exportsStr = this.exports.map((m) => `* ${m.toString()}`).join('\n');
     return `${chalk.bold.underline(this.namespace)}\n${exportsStr}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      exports: this.exports.map((member) => member.toObject()),
+      internals: this.internals.map((member) => member.toObject()),
+      namespace: this.namespace,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ModuleSchema {
+    const location = obj.location;
+    const exportNodes = (obj.exports || []).map((member: any) => SchemaRegistry.fromObject(member));
+    const internals = (obj.internals || []).map((member: any) => SchemaRegistry.fromObject(member));
+    const namespace = obj.namespace;
+    const module = new ModuleSchema(location, exportNodes, internals);
+    module.namespace = namespace;
+    return module;
+  }
 }