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

package/dist/schemas/type-ref.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeRefSchema = void 0;
 const component_1 = require("@teambit/component");
+const chalk_1 = __importDefault(require("chalk"));
 class TypeRefSchema {
     constructor(
     /**
@@ -15,14 +19,36 @@ class TypeRefSchema {
     /**
      * target package name. existing if type is defined in different package.
      */
-    packageName, node) {
+    packageName) {
         this.name = name;
         this.componentId = componentId;
         this.packageName = packageName;
-        this.node = node;
+    }
+    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_1.default.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) {
-        return new TypeRefSchema(plainSchema.name, plainSchema.componentId ? component_1.ComponentID.fromString(plainSchema.componentId) : undefined, plainSchema.packageName, plainSchema.node);
+        return new TypeRefSchema(plainSchema.name, plainSchema.componentId ? component_1.ComponentID.fromString(plainSchema.componentId) : undefined, plainSchema.packageName);
     }
 }
 exports.TypeRefSchema = TypeRefSchema;

package/dist/schemas/type-ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-ref.js","sourceRoot":"","sources":["../../schemas/type-ref.ts"],"names":[],"mappings":";;;AAAA,kDAAiD;AAUjD,MAAa,aAAa;IACxB;IACE;;OAEG;IACM,IAAY;IAErB;;OAEG;IACM,WAAyB;IAElC;;OAEG;IACM,WAAoB,EAEpB,IAAiB;QAZjB,SAAI,GAAJ,IAAI,CAAQ;QAKZ,gBAAW,GAAX,WAAW,CAAc;QAKzB,gBAAW,GAAX,WAAW,CAAS;QAEpB,SAAI,GAAJ,IAAI,CAAa;IACzB,CAAC;IAEJ,MAAM,CAAC,IAAI,CAAC,WAA+B;QACzC,OAAO,IAAI,aAAa,CACtB,WAAW,CAAC,IAAI,EAChB,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,uBAAW,CAAC,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,EACrF,WAAW,CAAC,WAAW,EACvB,WAAW,CAAC,IAAI,CACjB,CAAC;IACJ,CAAC;CACF;AA5BD,sCA4BC"}
+{"version":3,"file":"type-ref.js","sourceRoot":"","sources":["../../schemas/type-ref.ts"],"names":[],"mappings":";;;;;;AAAA,kDAAiD;AACjD,kDAA0B;AAS1B,MAAa,aAAa;IACxB;IACE;;OAEG;IACM,IAAY;IAErB;;OAEG;IACM,WAAyB;IAElC;;OAEG;IACM,WAAoB;QAVpB,SAAI,GAAJ,IAAI,CAAQ;QAKZ,gBAAW,GAAX,WAAW,CAAc;QAKzB,gBAAW,GAAX,WAAW,CAAS;IAC5B,CAAC;IAEJ,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,WAAW,EAAE,IAAI,CAAC,WAAW;SAC9B,CAAC;IACJ,CAAC;IAED,QAAQ;QACN,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;SAC3C;QACD,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,OAAO,GAAG,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;SACtD;QACD,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;OAEG;IACH,mBAAmB;QACjB,OAAO,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC;IAChD,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,WAA+B;QACzC,OAAO,IAAI,aAAa,CACtB,WAAW,CAAC,IAAI,EAChB,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,uBAAW,CAAC,UAAU,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,EACrF,WAAW,CAAC,WAAW,CACxB,CAAC;IACJ,CAAC;CACF;AAnDD,sCAmDC"}

package/dist/schemas/type-union.d.ts

@@ -0,0 +1,12 @@
+import { SchemaNode } from '../schema-node';
+export declare class TypeUnionSchema implements SchemaNode {
+    private types;
+    constructor(types: SchemaNode[]);
+    toObject(): {
+        constructorName: string;
+        types: (Record<string, any> & {
+            constructorName: string;
+        })[];
+    };
+    toString(): string;
+}

package/dist/schemas/type-union.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeUnionSchema = void 0;
+class TypeUnionSchema {
+    constructor(types) {
+        this.types = types;
+    }
+    toObject() {
+        return {
+            constructorName: this.constructor.name,
+            types: this.types.map((type) => type.toObject()),
+        };
+    }
+    toString() {
+        return `${this.types.map((type) => type.toString()).join(' | ')}`;
+    }
+}
+exports.TypeUnionSchema = TypeUnionSchema;
+//# sourceMappingURL=type-union.js.map

package/dist/schemas/type-union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-union.js","sourceRoot":"","sources":["../../schemas/type-union.ts"],"names":[],"mappings":";;;AAEA,MAAa,eAAe;IAC1B,YAAoB,KAAmB;QAAnB,UAAK,GAAL,KAAK,CAAc;IAAG,CAAC;IAC3C,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;SACjD,CAAC;IACJ,CAAC;IACD,QAAQ;QACN,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IACpE,CAAC;CACF;AAXD,0CAWC"}

package/dist/schemas/type.d.ts

@@ -0,0 +1,16 @@
+import { SchemaNode } from '../schema-node';
+export declare class TypeSchema implements SchemaNode {
+    private name;
+    private type;
+    private signature;
+    constructor(name: string, type: SchemaNode, signature: string);
+    toObject(): {
+        constructorName: string;
+        name: string;
+        type: Record<string, any> & {
+            constructorName: string;
+        };
+        signature: string;
+    };
+    toString(): string;
+}

package/dist/schemas/type.js

@@ -1 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeSchema = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class TypeSchema {
+    constructor(name, type, signature) {
+        this.name = name;
+        this.type = type;
+        this.signature = signature;
+    }
+    toObject() {
+        return {
+            constructorName: this.constructor.name,
+            name: this.name,
+            type: this.type.toObject(),
+            signature: this.signature,
+        };
+    }
+    toString() {
+        return `${chalk_1.default.bold(this.name)}: ${this.type.toString()}`;
+    }
+}
+exports.TypeSchema = TypeSchema;
 //# sourceMappingURL=type.js.map

package/dist/schemas/type.js.map

@@ -1 +1 @@
-{"version":3,"file":"type.js","sourceRoot":"","sources":["../../schemas/type.ts"],"names":[],"mappings":""}
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../schemas/type.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAG1B,MAAa,UAAU;IACrB,YAAoB,IAAY,EAAU,IAAgB,EAAU,SAAiB;QAAjE,SAAI,GAAJ,IAAI,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAY;QAAU,cAAS,GAAT,SAAS,CAAQ;IAAG,CAAC;IACzF,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAC1B,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;IACD,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AAbD,gCAaC"}

package/dist/schemas/variable.d.ts

@@ -0,0 +1,17 @@
+import { SchemaNode } from '../schema-node';
+export declare class VariableSchema implements SchemaNode {
+    readonly name: string;
+    private signature;
+    private type;
+    constructor(name: string, signature: string, type: SchemaNode);
+    getSignature(): string;
+    toObject(): {
+        constructorName: string;
+        name: string;
+        signature: string;
+        type: Record<string, any> & {
+            constructorName: string;
+        };
+    };
+    toString(): string;
+}

package/dist/schemas/variable.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableSchema = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+class VariableSchema {
+    constructor(name, signature, type) {
+        this.name = name;
+        this.signature = signature;
+        this.type = type;
+    }
+    getSignature() {
+        return this.signature;
+    }
+    toObject() {
+        return {
+            constructorName: this.constructor.name,
+            name: this.name,
+            signature: this.signature,
+            type: this.type.toObject(),
+        };
+    }
+    toString() {
+        return `${chalk_1.default.bold(this.name)}: ${this.type.toString()}`;
+    }
+}
+exports.VariableSchema = VariableSchema;
+//# sourceMappingURL=variable.js.map

package/dist/schemas/variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variable.js","sourceRoot":"","sources":["../../schemas/variable.ts"],"names":[],"mappings":";;;;;;AAAA,kDAA0B;AAG1B,MAAa,cAAc;IACzB,YAAqB,IAAY,EAAU,SAAiB,EAAU,IAAgB;QAAjE,SAAI,GAAJ,IAAI,CAAQ;QAAU,cAAS,GAAT,SAAS,CAAQ;QAAU,SAAI,GAAJ,IAAI,CAAY;IAAG,CAAC;IAC1F,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,QAAQ;QACN,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;YACtC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;SAC3B,CAAC;IACJ,CAAC;IAED,QAAQ;QACN,OAAO,GAAG,eAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC7D,CAAC;CACF;AAlBD,wCAkBC"}

package/index.ts

@@ -1,4 +1,30 @@
-export { SemanticSchema } from './semantic-schema';
-export type { SchemaNode } from './schema-node';
-export { Export, Module, StaticProperties, FunctionSchema, TypeRefSchema } from './schemas';
+export { APISchema } from './api-schema';
+export type { SchemaNode, Location } from './schema-node';
+export {
+  Export,
+  Module,
+  StaticProperties,
+  FunctionLikeSchema,
+  Modifier,
+  TypeRefSchema,
+  VariableSchema,
+  ClassSchema,
+  ConstructorSchema,
+  TypeSchema,
+  TypeIntersectionSchema,
+  TypeUnionSchema,
+  TypeLiteralSchema,
+  IndexSignatureSchema,
+  InterfaceSchema,
+  GetAccessorSchema,
+  SetAccessorSchema,
+  TypeQuerySchema,
+  InferenceTypeSchema,
+  LiteralTypeSchema,
+  KeywordTypeSchema,
+  TypeArraySchema,
+  TypeOperatorSchema,
+  TupleTypeSchema,
+  ParameterSchema,
+} from './schemas';
 export type { JSONSchema, JSONSchemaObject } from './json-schema';

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@teambit/semantics.entities.semantic-schema",
-  "version": "0.0.7",
+  "version": "0.0.10",
   "homepage": "https://bit.dev/teambit/semantics/entities/semantic-schema",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.semantics",
     "name": "entities/semantic-schema",
-    "version": "0.0.7"
+    "version": "0.0.10"
   },
   "dependencies": {
+    "chalk": "2.4.2",
     "json-schema": "0.4.0"
   },
   "devDependencies": {

package/{preview-1650468178717.js → preview-1652757984397.js}

@@ -1 +1 @@
-export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.semantics_entities_semantic-schema@0.0.7/dist/semantic-schema.docs.md')]
+export const overview = [require('/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.semantics_entities_semantic-schema@0.0.10/dist/semantic-schema.docs.md')]

package/schema-node.ts

@@ -1,11 +1,13 @@
 /**
- * an interface for implmenting a new schema node.
+ * an interface for implementing a new schema node.
  */
 export interface SchemaNode {
+  readonly location?: Location;
+  getSignature?(): string;
+
   toString(): string;
 
-  /**
-   * TODO: this should be made mandatory. this is the main serialization method.
-   */
-  toObject?(): string;
+  toObject(): Record<string, any> & { constructorName: string };
 }
+
+export type Location = { file: string; line: number; character: number };

package/schemas/class.ts

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { Location, SchemaNode } from '../schema-node';
+
+export class ClassSchema implements SchemaNode {
+  constructor(readonly className: string, readonly members: SchemaNode[], readonly location: Location) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.className,
+      members: this.members.map((member) => member.toObject()),
+    };
+  }
+
+  toString() {
+    const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
+    return `${chalk.bold.underline(this.className)}\n${membersStr}`;
+  }
+}

package/schemas/constructor.ts

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+import { ParameterSchema } from './parameter';
+
+export class ConstructorSchema implements SchemaNode {
+  constructor(readonly params: ParameterSchema[]) {}
+
+  toString() {
+    const paramsStr = this.params.map((param) => param.toString()).join(', ');
+    return `${chalk.bold('constructor')}(${paramsStr})`;
+  }
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      args: this.params.map((arg) => arg.toObject()),
+    };
+  }
+}

package/schemas/export.ts

@@ -3,7 +3,7 @@ import { SchemaNode } from '../schema-node';
 type Primitive = string | number | boolean | null | undefined;
 export type StaticProperties = Map<string, Primitive>;
 
-export class Export {
+export class Export implements SchemaNode {
   constructor(
     /**
      * named export identifier of the module export.
@@ -13,7 +13,7 @@ export class Export {
     /**
      * API node.
      */
-    readonly node?: SchemaNode,
+    readonly nodes?: SchemaNode[],
 
     /**
      * static properties attached to this export
@@ -24,4 +24,11 @@ export class Export {
      */
     readonly staticProperties?: StaticProperties
   ) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      identifier: this.identifier,
+    };
+  }
 }

package/schemas/function-like.ts

@@ -0,0 +1,43 @@
+import chalk from 'chalk';
+import { Location, SchemaNode } from '../schema-node';
+import { ParameterSchema } from './parameter';
+
+export type Modifier = 'static' | 'public' | 'private' | 'protected' | 'readonly' | 'abstract' | 'async' | 'override';
+
+export class FunctionLikeSchema implements SchemaNode {
+  constructor(
+    readonly name: string,
+    // readonly doc: any,
+    readonly params: ParameterSchema[],
+
+    readonly returnType: SchemaNode,
+    readonly signature: string,
+    readonly location: Location,
+    readonly modifiers: Modifier[] = []
+  ) {}
+
+  serialize() {}
+
+  toJsonSchema() {}
+
+  getSignature() {
+    return this.signature;
+  }
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+      params: this.params,
+      returnType: this.returnType.toObject(),
+      signature: this.signature,
+      modifiers: this.modifiers,
+    };
+  }
+
+  toString() {
+    const paramsStr = this.params.map((param) => param.toString()).join(', ');
+    const modifiersStr = this.modifiers.length ? `${this.modifiers.join(' ')} ` : '';
+    return `${modifiersStr}${chalk.bold(this.name)}(${paramsStr}): ${this.returnType.toString()}`;
+  }
+}

package/schemas/get-accessor.ts

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import { SchemaNode } from '../schema-node';
+
+export class GetAccessorSchema implements SchemaNode {
+  constructor(private name: string, private type: SchemaNode, 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,21 @@
+import { SchemaNode } from '../schema-node';
+import { ParameterSchema } from './parameter';
+
+/**
+ * e.g. `{ [key: string]: boolean };`
+ * the "[key: string]" is the "parameter", and the "boolean" is the "type".
+ */
+export class IndexSignatureSchema implements SchemaNode {
+  constructor(private params: ParameterSchema[], private type: SchemaNode) {}
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      parameters: this.params,
+      type: this.type.toObject(),
+    };
+  }
+  toString() {
+    const paramsStr = this.params.map((param) => param.toString()).join(', ');
+    return `[${paramsStr}]: ${this.type.toString()}`;
+  }
+}

package/schemas/index.ts

@@ -1,4 +1,23 @@
 export { Module } from './module';
 export { Export, StaticProperties } from './export';
-export { FunctionSchema } from './function';
+export { FunctionLikeSchema, Modifier } from './function-like';
 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';
+export { TypeQuerySchema } from './type-query';
+export { InferenceTypeSchema } from './inference-type';
+export { LiteralTypeSchema } from './literal-type';
+export { KeywordTypeSchema } from './keyword-type';
+export { TypeArraySchema } from './type-array';
+export { TypeOperatorSchema } from './type-operator';
+export { TupleTypeSchema } from './tuple-type';
+export { ParameterSchema } from './parameter';

package/schemas/inference-type.ts

@@ -0,0 +1,19 @@
+import { SchemaNode } from '../schema-node';
+
+/**
+ * where there is no explicit type, the type is taken from the "quickinfo" of tsserver
+ */
+export class InferenceTypeSchema implements SchemaNode {
+  constructor(private type: string) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      type: this.type,
+    };
+  }
+
+  toString() {
+    return this.type;
+  }
+}

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/keyword-type.ts

@@ -0,0 +1,19 @@
+import { SchemaNode } from '../schema-node';
+
+/**
+ * e.g. 'string', 'boolean', etc.
+ */
+export class KeywordTypeSchema implements SchemaNode {
+  constructor(private name: string) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+    };
+  }
+
+  toString() {
+    return this.name;
+  }
+}

package/schemas/literal-type.ts

@@ -0,0 +1,19 @@
+import { SchemaNode } from '../schema-node';
+
+/**
+ * e.g. const a: 'a';
+ */
+export class LiteralTypeSchema implements SchemaNode {
+  constructor(private name: string) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+    };
+  }
+
+  toString() {
+    return this.name;
+  }
+}

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/parameter.ts

@@ -0,0 +1,23 @@
+import { SchemaNode } from '../schema-node';
+
+export class ParameterSchema implements SchemaNode {
+  constructor(
+    readonly name: string,
+    readonly type: SchemaNode,
+    readonly defaultValue?: any,
+    readonly description?: string
+  ) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      name: this.name,
+      type: this.type.toObject(),
+      defaultValue: this.defaultValue,
+      description: this.description,
+    };
+  }
+  toString() {
+    return `${this.name}: ${this.type.toString()}`;
+  }
+}

package/schemas/set-accessor.ts

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

package/schemas/tuple-type.ts

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