@teambit/semantics.entities.semantic-schema 0.0.7 → 0.0.10

package/schemas/type-array.ts

@@ -0,0 +1,14 @@
+import { SchemaNode } from '../schema-node';
+
+export class TypeArraySchema implements SchemaNode {
+  constructor(private type: SchemaNode) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      type: this.type.toObject(),
+    };
+  }
+  toString() {
+    return `${this.type.toString()}[]`;
+  }
+}

package/schemas/type-intersection.ts

@@ -0,0 +1,14 @@
+import { SchemaNode } from '../schema-node';
+
+export class TypeIntersectionSchema implements SchemaNode {
+  constructor(private types: SchemaNode[]) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      types: this.types.map((type) => type.toObject()),
+    };
+  }
+  toString() {
+    return `${this.types.map((type) => type.toString()).join(' & ')}`;
+  }
+}

package/schemas/type-literal.ts

@@ -0,0 +1,17 @@
+import { SchemaNode } from '../schema-node';
+
+/**
+ * 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()),
+    };
+  }
+  toString() {
+    return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;
+  }
+}

package/schemas/type-operator.ts

@@ -0,0 +1,15 @@
+import { SchemaNode } from '../schema-node';
+
+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(),
+    };
+  }
+  toString() {
+    return `${this.operatorName} ${this.type.toString()}`;
+  }
+}

package/schemas/type-query.ts

@@ -0,0 +1,23 @@
+import { SchemaNode } from '../schema-node';
+
+/**
+ * e.g. `typeof Foo`
+ */
+export class TypeQuerySchema implements SchemaNode {
+  constructor(private type: SchemaNode, private signature: string) {}
+  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,11 +1,11 @@
 import { ComponentID } from '@teambit/component';
+import chalk from 'chalk';
 import { SchemaNode } from '../schema-node';
 
 export type PlainTypeRefSchema = {
   name: string;
   componentId?: string;
   packageName?: string;
-  node?: SchemaNode;
 };
 
 export class TypeRefSchema implements SchemaNode {
@@ -23,17 +23,40 @@ export class TypeRefSchema implements SchemaNode {
     /**
      * target package name. existing if type is defined in different package.
      */
-    readonly packageName?: string,
-
-    readonly node?: SchemaNode
+    readonly packageName?: string
   ) {}
 
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+      componentId: this.componentId,
+      packageName: this.packageName,
+    };
+  }
+
+  toString() {
+    if (this.componentId) {
+      return `${this.componentId}/${this.name}`;
+    }
+    if (this.packageName) {
+      return `${chalk.dim(this.packageName)}/${this.name}`;
+    }
+    return this.name;
+  }
+
+  /**
+   * whether this type was already exported in this component
+   */
+  isFromThisComponent() {
+    return !this.componentId && !this.packageName;
+  }
+
   static from(plainSchema: PlainTypeRefSchema) {
     return new TypeRefSchema(
       plainSchema.name,
       plainSchema.componentId ? ComponentID.fromString(plainSchema.componentId) : undefined,
-      plainSchema.packageName,
-      plainSchema.node
+      plainSchema.packageName
     );
   }
 }

package/schemas/type-union.ts

@@ -0,0 +1,14 @@
+import { SchemaNode } from '../schema-node';
+
+export class TypeUnionSchema implements SchemaNode {
+  constructor(private types: SchemaNode[]) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      types: this.types.map((type) => type.toObject()),
+    };
+  }
+  toString() {
+    return `${this.types.map((type) => type.toString()).join(' | ')}`;
+  }
+}

package/schemas/type.ts

@@ -0,0 +1,17 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+
+export class TypeSchema implements SchemaNode {
+  constructor(private name: string, private type: SchemaNode, private signature: string) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+      type: this.type.toObject(),
+      signature: this.signature,
+    };
+  }
+  toString() {
+    return `${chalk.bold(this.name)}: ${this.type.toString()}`;
+  }
+}

package/schemas/variable.ts

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+
+export class VariableSchema implements SchemaNode {
+  constructor(readonly name: string, private signature: string, private type: SchemaNode) {}
+  getSignature() {
+    return this.signature;
+  }
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+      signature: this.signature,
+      type: this.type.toObject(),
+    };
+  }
+
+  toString() {
+    return `${chalk.bold(this.name)}: ${this.type.toString()}`;
+  }
+}

package/dist/schemas/function.d.ts

@@ -1,16 +0,0 @@
-import { SchemaNode } from '../schema-node';
-import { TypeRefSchema } from './type-ref';
-export declare type Argument = {
-    name: string;
-    defaultValue?: any;
-    description: any;
-    type: string;
-};
-export declare class FunctionSchema implements SchemaNode {
-    readonly name: string;
-    readonly args: Argument[];
-    readonly returnType: TypeRefSchema;
-    constructor(name: string, args: Argument[], returnType: TypeRefSchema);
-    serialize(): void;
-    toJsonSchema(): void;
-}

package/dist/schemas/function.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionSchema = void 0;
-class FunctionSchema {
-    constructor(name, 
-    // readonly doc: any,
-    args, returnType) {
-        this.name = name;
-        this.args = args;
-        this.returnType = returnType;
-    }
-    serialize() { }
-    toJsonSchema() { }
-}
-exports.FunctionSchema = FunctionSchema;
-//# sourceMappingURL=function.js.map

package/dist/schemas/function.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"function.js","sourceRoot":"","sources":["../../schemas/function.ts"],"names":[],"mappings":";;;AAUA,MAAa,cAAc;IACzB,YACW,IAAY;IACrB,qBAAqB;IACZ,IAAgB,EAEhB,UAAyB;QAJzB,SAAI,GAAJ,IAAI,CAAQ;QAEZ,SAAI,GAAJ,IAAI,CAAY;QAEhB,eAAU,GAAV,UAAU,CAAe;IACjC,CAAC;IAEJ,SAAS,KAAI,CAAC;IAEd,YAAY,KAAI,CAAC;CAClB;AAZD,wCAYC"}

package/dist/semantic-schema.d.ts

@@ -1,12 +0,0 @@
-import { Export } from './schemas';
-import { SchemaNode } from './schema-node';
-export declare type PlainSemanticSchema = {
-    exports?: Export[];
-};
-export declare class SemanticSchema implements SchemaNode {
-    readonly exports: Export[];
-    constructor(exports?: Export[]);
-    toString(): string;
-    static fromSchema(): void;
-    static from(plainSchema: PlainSemanticSchema): SemanticSchema;
-}

package/dist/semantic-schema.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SemanticSchema = void 0;
-class SemanticSchema {
-    constructor(exports = []) {
-        this.exports = exports;
-    }
-    toString() {
-        return '';
-    }
-    static fromSchema() { }
-    static from(plainSchema) {
-        return new SemanticSchema(plainSchema.exports);
-    }
-}
-exports.SemanticSchema = SemanticSchema;
-//# sourceMappingURL=semantic-schema.js.map

package/dist/semantic-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"semantic-schema.js","sourceRoot":"","sources":["../semantic-schema.ts"],"names":[],"mappings":";;;AAOA,MAAa,cAAc;IACzB,YAAqB,UAAoB,EAAE;QAAtB,YAAO,GAAP,OAAO,CAAe;IAAG,CAAC;IAE/C,QAAQ;QACN,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,CAAC,UAAU,KAAI,CAAC;IAEtB,MAAM,CAAC,IAAI,CAAC,WAAgC;QAC1C,OAAO,IAAI,cAAc,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IACjD,CAAC;CACF;AAZD,wCAYC"}

package/schemas/function.ts

@@ -1,23 +0,0 @@
-import { SchemaNode } from '../schema-node';
-import { TypeRefSchema } from './type-ref';
-
-export type Argument = {
-  name: string;
-  defaultValue?: any;
-  description: any;
-  type: string;
-};
-
-export class FunctionSchema implements SchemaNode {
-  constructor(
-    readonly name: string,
-    // readonly doc: any,
-    readonly args: Argument[],
-
-    readonly returnType: TypeRefSchema
-  ) {}
-
-  serialize() {}
-
-  toJsonSchema() {}
-}

package/semantic-schema.ts

@@ -1,20 +0,0 @@
-import { Export } from './schemas';
-import { SchemaNode } from './schema-node';
-
-export type PlainSemanticSchema = {
-  exports?: Export[];
-};
-
-export class SemanticSchema implements SchemaNode {
-  constructor(readonly exports: Export[] = []) {}
-
-  toString() {
-    return '';
-  }
-
-  static fromSchema() {}
-
-  static from(plainSchema: PlainSemanticSchema) {
-    return new SemanticSchema(plainSchema.exports);
-  }
-}