@teambit/semantics.entities.semantic-schema 0.0.53 → 0.0.56

package/schemas/unimplemented-schema.ts

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

package/schemas/unknown-schema.ts

@@ -1,4 +1,4 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 
 /**
  * needed for better backward and forward compatibility.
@@ -6,11 +6,25 @@ import { Location, SchemaNode } from '../schema-node';
  * wrapped in this class.
  */
 export class UnknownSchema extends SchemaNode {
-  constructor(readonly location: Location, readonly name: string, readonly schemaObj: Record<string, any>) {
+  constructor(readonly location: SchemaLocation, readonly name: string, readonly schemaObj: Record<string, any>) {
     super();
   }
 
   toString() {
     return `<<unknown schema ${this.name}>>`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      schemaObj: this.schemaObj,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): UnknownSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const schemaObj = obj.schemaObj;
+    return new UnknownSchema(location, name, schemaObj);
+  }
 }

package/schemas/unresolved-schema.ts

@@ -1,15 +1,25 @@
-import { Location, SchemaNode } from '../schema-node';
+import { SchemaLocation, SchemaNode } from '../schema-node';
 
 /**
  * needed for cases when the exported entity could not be resolved.
  * e.g. exporting mdx variables in the main index.ts file.
  */
 export class UnresolvedSchema 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();
+  }
+
+  static fromObject(obj: Record<string, any>): UnresolvedSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new UnresolvedSchema(location, name);
+  }
 }

package/schemas/variable-like.ts

@@ -1,32 +1,57 @@
-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 { DocSchema } from './docs';
+import { SchemaRegistry } from '../schema-registry';
 
 /**
  * can be also a property or property-signature
  */
 export class VariableLikeSchema extends SchemaNode {
-  @Transform(schemaObjToInstance)
   type: SchemaNode;
-
-  @Transform(schemaObjToInstance)
   readonly doc?: DocSchema;
+
   constructor(
-    readonly location: Location,
+    readonly location: SchemaLocation,
     readonly name: string,
     readonly signature: string,
     type: SchemaNode,
     readonly isOptional: boolean,
-    doc?: DocSchema
+    doc?: DocSchema,
+    readonly defaultValue?: string
   ) {
     super();
     this.type = type;
     this.doc = doc;
   }
 
+  getNodes() {
+    return [this.type];
+  }
+
   toString() {
     return `${chalk.bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
   }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      signature: this.signature,
+      type: this.type.toObject(),
+      isOptional: this.isOptional,
+      doc: this.doc?.toObject(),
+      defaultValue: this.defaultValue,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): VariableLikeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const signature = obj.signature;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const isOptional = obj.isOptional;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const defaultValue = obj.defaultValue;
+    return new VariableLikeSchema(location, name, signature, type, isOptional, doc, defaultValue);
+  }
 }

package/unknown-schema-factory.ts

@@ -0,0 +1,10 @@
+import { SchemaLocation } from './schema-node';
+
+export class UnknownSchemaFactory {
+  static create(location: SchemaLocation, name: string, schemaObj: Record<string, any>): any {
+    // dynamic require() to import UnknownSchema at runtime when it's needed, which breaks the circular dependency.
+    // eslint-disable-next-line global-require
+    const { UnknownSchema } = require('./schemas/unknown-schema');
+    return new UnknownSchema(location, name, schemaObj);
+  }
+}