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

package/schemas/named-tuple.ts

@@ -1,11 +1,31 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export class NamedTupleSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly type: SchemaNode, readonly name?: string) {
+  constructor(readonly location: SchemaLocation, readonly type: SchemaNode, readonly name?: string) {
     super();
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `${this.name}: ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): NamedTupleSchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const name = obj.name;
+    return new NamedTupleSchema(location, type, name);
+  }
 }

package/schemas/parameter.ts

@@ -1,29 +1,61 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjToInstance } from '../class-transformers';
-import { schemaObjArrayToInstances } from '../class-transformers/schema-obj-to-class';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
-export class ParameterSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
-  readonly type: SchemaNode;
-  @Transform(schemaObjArrayToInstances)
+export class ParameterSchema<T extends SchemaNode = SchemaNode> extends SchemaNode {
+  readonly type: T;
   readonly objectBindingNodes?: SchemaNode[];
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
-    type: SchemaNode,
+    type: T,
     readonly isOptional: boolean,
     readonly defaultValue?: any,
     readonly description?: string,
-    objectBindingNodes?: SchemaNode[]
+    objectBindingNodes?: SchemaNode[],
+    readonly isSpread: boolean = false
   ) {
     super();
     this.type = type;
     this.objectBindingNodes = objectBindingNodes;
+    this.isSpread = isSpread;
   }
 
   toString() {
     return `${this.name}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject(),
+      isOptional: this.isOptional,
+      defaultValue: this.defaultValue,
+      description: this.description,
+      objectBindingNodes: this.objectBindingNodes?.map((node) => node.toObject()),
+      isSpread: this.isSpread,
+    };
+  }
+
+  static fromObject<T extends SchemaNode = SchemaNode>(obj: Record<string, any>): ParameterSchema<T> {
+    const location = obj.location;
+    const name = obj.name;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const isOptional = obj.isOptional;
+    const defaultValue = obj.defaultValue;
+    const description = obj.description;
+    const isSpread = obj.isSpread;
+    const objectBindingNodes = obj.objectBindingNodes?.map((node: any) => SchemaRegistry.fromObject(node));
+    return new ParameterSchema(
+      location,
+      name,
+      type,
+      isOptional,
+      defaultValue,
+      description,
+      objectBindingNodes,
+      isSpread
+    );
+  }
 }

package/schemas/parenthesized-type.ts

@@ -1,20 +1,35 @@
-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';
 
 /**
  * type inside parentheses
  * e.g. (T1 | T2)
  */
 export class ParenthesizedTypeSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly type: SchemaNode;
-  constructor(readonly location: Location, type: SchemaNode) {
+  constructor(readonly location: SchemaLocation, type: SchemaNode) {
     super();
     this.type = type;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `(${this.type.toString()})`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ParenthesizedTypeSchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new ParenthesizedTypeSchema(location, type);
+  }
 }

package/schemas/set-accessor.ts

@@ -1,16 +1,20 @@
-import { Transform } from 'class-transformer';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { ParameterSchema } from './parameter';
-import { schemaObjToInstance } from '../class-transformers';
 
 export class SetAccessorSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly param: ParameterSchema;
-  constructor(readonly location: Location, readonly name: string, param: ParameterSchema, readonly signature: string) {
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    param: ParameterSchema,
+    readonly signature: string
+  ) {
     super();
     this.param = param;
   }
+
   getSignature() {
     return this.signature;
   }
@@ -18,4 +22,21 @@ export class SetAccessorSchema extends SchemaNode {
   toString() {
     return `set ${chalk.bold(this.name)}(${this.param.toString()})`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      param: this.param.toObject(),
+      signature: this.signature,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): SetAccessorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const param = ParameterSchema.fromObject(obj.param);
+    const signature = obj.signature;
+    return new SetAccessorSchema(location, name, param, signature);
+  }
 }

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

@@ -1,16 +1,34 @@
-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 TemplateLiteralTypeSpanSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   type: SchemaNode;
-  constructor(readonly location: Location, readonly literal: string, type: SchemaNode) {
+
+  constructor(readonly location: SchemaLocation, readonly literal: string, type: SchemaNode) {
     super();
     this.type = type;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `${this.type.toString()} ${this.literal}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      literal: this.literal,
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TemplateLiteralTypeSpanSchema {
+    const location = obj.location;
+    const literal = obj.literal;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new TemplateLiteralTypeSpanSchema(location, literal, type);
+  }
 }

package/schemas/template-literal-type.ts

@@ -1,12 +1,14 @@
-import { Transform } from 'class-transformer';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances } from '../class-transformers';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 import { TemplateLiteralTypeSpanSchema } from './template-literal-type-span';
 
 export class TemplateLiteralTypeSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly templateSpans: TemplateLiteralTypeSpanSchema[];
-  constructor(readonly location: Location, readonly head: string, templateSpans: TemplateLiteralTypeSpanSchema[]) {
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly head: string,
+    templateSpans: TemplateLiteralTypeSpanSchema[]
+  ) {
     super();
     this.templateSpans = templateSpans;
   }
@@ -15,4 +17,19 @@ export class TemplateLiteralTypeSchema extends SchemaNode {
     const spans = this.templateSpans.map((span) => span.toString()).join('');
     return `${this.head}${spans}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      head: this.head,
+      templateSpans: this.templateSpans.map((span) => span.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TemplateLiteralTypeSchema {
+    const location = obj.location;
+    const head = obj.head;
+    const templateSpans = obj.templateSpans.map((span: any) => TemplateLiteralTypeSpanSchema.fromObject(span));
+    return new TemplateLiteralTypeSchema(location, head, templateSpans);
+  }
 }

package/schemas/this-type.ts

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

package/schemas/tuple-type.ts

@@ -1,11 +1,10 @@
-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 TupleTypeSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly elements: SchemaNode[];
-  constructor(readonly location: Location, elements: SchemaNode[]) {
+
+  constructor(readonly location: SchemaLocation, elements: SchemaNode[]) {
     super();
     this.elements = elements;
   }
@@ -13,4 +12,17 @@ export class TupleTypeSchema extends SchemaNode {
   toString() {
     return `[${this.elements.map((elem) => elem.toString()).join(', ')}]`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      elements: this.elements.map((elem) => elem.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TupleTypeSchema {
+    const location = obj.location;
+    const elements = obj.elements.map((elem: any) => SchemaRegistry.fromObject(elem));
+    return new TupleTypeSchema(location, elements);
+  }
 }

package/schemas/type-array.ts

@@ -1,16 +1,32 @@
-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 TypeArraySchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly type: SchemaNode;
-  constructor(readonly location: Location, type: SchemaNode) {
+
+  constructor(readonly location: SchemaLocation, type: SchemaNode) {
     super();
     this.type = type;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `${this.type.toString()}[]`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeArraySchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new TypeArraySchema(location, type);
+  }
 }

package/schemas/type-intersection.ts

@@ -1,16 +1,32 @@
-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 TypeIntersectionSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly types: SchemaNode[];
-  constructor(readonly location: Location, types: SchemaNode[]) {
+
+  constructor(readonly location: SchemaLocation, types: SchemaNode[]) {
     super();
     this.types = types;
   }
 
+  getNodes() {
+    return this.types;
+  }
+
   toString() {
     return `${this.types.map((type) => type.toString()).join(' & ')}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      types: this.types.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeIntersectionSchema {
+    const location = obj.location;
+    const types = obj.types.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeIntersectionSchema(location, types);
+  }
 }

package/schemas/type-literal.ts

@@ -1,19 +1,35 @@
-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';
 
 /**
  * e.g. `{ a: string; b: number }`
  */
 export class TypeLiteralSchema extends SchemaNode {
-  @Transform(schemaObjArrayToInstances)
   readonly members: SchemaNode[];
-  constructor(readonly location: Location, members: SchemaNode[]) {
+
+  constructor(readonly location: SchemaLocation, members: SchemaNode[]) {
     super();
     this.members = members;
   }
 
+  getNodes() {
+    return this.members;
+  }
+
   toString() {
     return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      members: this.members.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeLiteralSchema {
+    const location = obj.location;
+    const members = obj.members.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeLiteralSchema(location, members);
+  }
 }

package/schemas/type-operator.ts

@@ -1,16 +1,33 @@
-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 TypeOperatorSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   type: SchemaNode;
-  constructor(readonly location: Location, readonly name: string, type: SchemaNode) {
+  constructor(readonly location: SchemaLocation, readonly name: string, type: SchemaNode) {
     super();
     this.type = type;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `${this.name} ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject(),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeOperatorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new TypeOperatorSchema(location, name, type);
+  }
 }

package/schemas/type-predicate.ts

@@ -1,6 +1,5 @@
-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';
 
 /**
  * e.g. `function f(str: any): str is string {}`
@@ -16,10 +15,9 @@ import { schemaObjToInstance } from '../class-transformers';
  *
  */
 export class TypePredicateSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly type?: SchemaNode;
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     type?: SchemaNode,
     readonly hasAssertsModifier = false
@@ -33,4 +31,21 @@ export class TypePredicateSchema extends SchemaNode {
     const typeStr = this.type ? ` is ${this.type.toString()}` : '';
     return assertsKeyword + this.name + typeStr;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type?.toObject(),
+      hasAssertsModifier: this.hasAssertsModifier,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypePredicateSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    const hasAssertsModifier = obj.hasAssertsModifier;
+    return new TypePredicateSchema(location, name, type, hasAssertsModifier);
+  }
 }

package/schemas/type-query.ts

@@ -1,17 +1,21 @@
-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';
 
 /**
  * e.g. `typeof Foo`
  */
 export class TypeQuerySchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   readonly type: SchemaNode;
-  constructor(readonly location: Location, type: SchemaNode, readonly signature: string) {
+
+  constructor(readonly location: SchemaLocation, type: SchemaNode, readonly signature: string) {
     super();
     this.type = type;
   }
+
+  getNodes() {
+    return [this.type];
+  }
+
   getSignature() {
     return this.signature;
   }
@@ -19,4 +23,19 @@ export class TypeQuerySchema extends SchemaNode {
   toString() {
     return `typeof ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type.toObject(),
+      signature: this.signature,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeQuerySchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const signature = obj.signature;
+    return new TypeQuerySchema(location, type, signature);
+  }
 }

package/schemas/type-ref.ts

@@ -1,9 +1,7 @@
-import { Transform } from 'class-transformer';
 import { ComponentID } from '@teambit/component';
 import chalk from 'chalk';
-import { Location, SchemaNode } from '../schema-node';
-import { schemaObjArrayToInstances } from '../class-transformers';
-import { componentIdTransformer } from '../class-transformers/comp-id-transformer';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
 
 export type PlainTypeRefSchema = {
   name: string;
@@ -19,38 +17,41 @@ export type PlainTypeRefSchema = {
  * 4. 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[];
 
-  @Transform(componentIdTransformer)
   readonly componentId?: ComponentID;
 
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     /**
      * name of the reference to type.
      */
     readonly name: string,
-
     /**
      * target component id. existing if the type is defined in another component.
      */
     componentId?: ComponentID,
-
     /**
      * target package name. existing if type is defined in different package.
      */
     readonly packageName?: string,
-
+    /**
+     * if the reference is not exported from the component, it can be internal to the file.
+     */
     readonly internalFilePath?: string
   ) {
     super();
     this.componentId = componentId;
   }
 
+  withTypeArgs(typeArgs: SchemaNode[]) {
+    this.typeArgs = typeArgs;
+    return this;
+  }
+
   toString() {
     const name = this.nameToString();
     if (!this.typeArgs) {
@@ -78,4 +79,44 @@ export class TypeRefSchema extends SchemaNode {
   isFromThisComponent() {
     return !this.componentId && !this.packageName;
   }
+
+  /**
+   * whether this type is internal to the file.
+   */
+  isInternalReference() {
+    return !!this.internalFilePath && this.isFromThisComponent();
+  }
+
+  /**
+   * whether this type is exported from this component.
+   */
+  isExported() {
+    return this.isFromThisComponent() && !this.isInternalReference();
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      componentId: this.componentId ? this.componentId.toObject() : undefined,
+      packageName: this.packageName,
+      internalFilePath: this.internalFilePath,
+      typeArgs: this.typeArgs?.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeRefSchema {
+    const location = obj.location;
+    const name = obj.name;
+    let componentId;
+    try {
+      componentId = obj.componentId ? ComponentID.fromObject(obj.componentId) : undefined;
+    } catch (e) {
+      componentId = undefined;
+    }
+    const packageName = obj.packageName;
+    const internalFilePath = obj.internalFilePath;
+    const typeArgs = obj.typeArgs?.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeRefSchema(location, name, componentId, packageName, internalFilePath).withTypeArgs(typeArgs);
+  }
 }