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

package/schemas/get-accessor.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+import { TypeRefSchema } from './type-ref';
+
+export class GetAccessorSchema implements SchemaNode {
+  constructor(private name: string, private type: TypeRefSchema, private signature: string) {}
+  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

@@ -0,0 +1,22 @@
+import { SchemaNode } from '../schema-node';
+import { Parameter } from './function';
+import { TypeRefSchema } from './type-ref';
+
+/**
+ * e.g. `{ [key: string]: boolean };`
+ * the "[key: string]" is the "parameter", and the "boolean" is the "type".
+ */
+export class IndexSignatureSchema implements SchemaNode {
+  constructor(private parameters: Parameter[], private type: TypeRefSchema) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      parameters: this.parameters,
+      type: this.type.toObject(),
+    };
+  }
+  toString() {
+    const parameters = this.parameters.map((arg) => `${arg.name}: ${arg.type.toString()}`).join(', ');
+    return `[${parameters}]: ${this.type.toString()}`;
+  }
+}

package/schemas/index.ts

@@ -1,4 +1,15 @@
 export { Module } from './module';
 export { Export, StaticProperties } from './export';
-export { FunctionSchema } from './function';
+export { FunctionSchema, Parameter } from './function';
 export { TypeRefSchema } from './type-ref';
+export { VariableSchema } from './variable';
+export { ClassSchema } from './class';
+export { ConstructorSchema } from './constructor';
+export { TypeSchema } from './type';
+export { TypeIntersectionSchema } from './type-intersection';
+export { TypeUnionSchema } from './type-union';
+export { TypeLiteralSchema } from './type-literal';
+export { IndexSignatureSchema } from './index-signature';
+export { InterfaceSchema } from './interface';
+export { GetAccessorSchema } from './get-accessor';
+export { SetAccessorSchema } from './set-accessor';

package/schemas/interface.ts

@@ -0,0 +1,17 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+
+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()),
+    };
+  }
+  toString() {
+    const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
+    return `${chalk.bold.underline(this.name)}\n${membersStr}`;
+  }
+}

package/schemas/module.ts

@@ -1,11 +1,40 @@
-import { Export } from './export';
+import chalk from 'chalk';
 import { SchemaNode } from '../schema-node';
+import { Export } from '../schemas';
 
 export class Module implements SchemaNode {
-  constructor(
-    /**
-     * all module exports.
-     */
-    readonly exports: Export[]
-  ) {}
+  namespace?: string;
+  constructor(public exports: SchemaNode[]) {}
+
+  getExportSchemas(): Export[] {
+    return this.exports.filter((e) => e instanceof Export) as Export[];
+  }
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      namespace: this.namespace,
+      exports: this.exports.map((exp) => exp.toObject()),
+    };
+  }
+
+  flatExportsRecursively() {
+    this.exports = this.exports.reduce((acc, exp) => {
+      if (exp instanceof Module) {
+        exp.flatExportsRecursively();
+        if (exp.namespace) return [...acc, exp];
+        return [...acc, ...exp.exports];
+      }
+      return [...acc, exp];
+    }, [] as SchemaNode[]);
+  }
+
+  toString() {
+    if (!this.namespace)
+      throw new Error(
+        'toString() should not be called on a module without namespace, make sure this.flatExportsRecursively() is called'
+      );
+    const exportsStr = this.exports.map((m) => `* ${m.toString()}`).join('\n');
+    return `${chalk.bold.underline(this.namespace)}\n${exportsStr}`;
+  }
 }

package/schemas/set-accessor.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import { Parameter } from '.';
+import { SchemaNode } from '../schema-node';
+
+export class SetAccessorSchema implements SchemaNode {
+  constructor(private name: string, private param: Parameter, private signature: string) {}
+  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.name}: ${this.param.type})`;
+  }
+}

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-ref.ts

@@ -1,4 +1,5 @@
 import { ComponentID } from '@teambit/component';
+import chalk from 'chalk';
 import { SchemaNode } from '../schema-node';
 
 export type PlainTypeRefSchema = {
@@ -28,6 +29,25 @@ export class TypeRefSchema implements SchemaNode {
     readonly node?: SchemaNode
   ) {}
 
+  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;
+  }
+
   static from(plainSchema: PlainTypeRefSchema) {
     return new TypeRefSchema(
       plainSchema.name,

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,23 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+import { TypeRefSchema } from './type-ref';
+
+export class VariableSchema implements SchemaNode {
+  constructor(readonly name: string, private signature: string, private type: TypeRefSchema) {}
+  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/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/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);
-  }
-}