@teambit/semantics.entities.semantic-schema 0.0.0-e4ef0e951da794f03096a5cc407420f4cde8b878

package/schemas/keyword-type.ts

@@ -0,0 +1,34 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+/**
+ * e.g. 'string', 'boolean', etc.
+ */
+export class KeywordTypeSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string
+  ) {
+    super();
+  }
+
+  toString() {
+    return this.name;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): KeywordTypeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new KeywordTypeSchema(location, name);
+  }
+}

package/schemas/literal-type.ts

@@ -0,0 +1,34 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+/**
+ * e.g. const a: 'a';
+ */
+export class LiteralTypeSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string
+  ) {
+    super();
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+    };
+  }
+
+  toString() {
+    return this.name;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  static fromObject(obj: Record<string, any>): LiteralTypeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new LiteralTypeSchema(location, name);
+  }
+}

package/schemas/literal-value.ts

@@ -0,0 +1,32 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+export class LiteralValueSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly value: string
+  ) {
+    super();
+    this.value = this.value.replace(/^['"]|['"]$/g, '');
+  }
+
+  toString() {
+    return this.value;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      value: this.value,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): LiteralValueSchema {
+    const location = obj.location;
+    const value = obj.value;
+    return new LiteralValueSchema(location, value);
+  }
+}

package/schemas/module.ts

@@ -0,0 +1,87 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+import { ExportSchema } from './export';
+
+export class ModuleSchema extends SchemaNode {
+  // exports could either be re exports (export declarations) or nodes with export modifier
+  exports: SchemaNode[];
+  internals: SchemaNode[];
+  namespace?: string;
+
+  constructor(
+    readonly location: SchemaLocation,
+    exports: SchemaNode[],
+    internals: SchemaNode[]
+  ) {
+    super();
+    this.exports = exports;
+    this.internals = internals;
+  }
+
+  getNodes() {
+    return [...this.exports, ...this.internals];
+  }
+
+  flatExportsRecursively() {
+    this.exports = this.exports.reduce(
+      (acc, exp) => {
+        if (exp instanceof ModuleSchema) {
+          exp.flatExportsRecursively();
+          if (exp.namespace) return [...acc, exp];
+          return [...acc, ...exp.exports];
+        }
+        return [...acc, exp];
+      },
+      [] as (ExportSchema | SchemaNode)[]
+    );
+  }
+
+  toString(options?: { color?: boolean }) {
+    if (!this.namespace)
+      throw new Error(
+        'toString() should not be called on a module without namespace, make sure this.flatExportsRecursively() is called'
+      );
+    const boldUnderline = options?.color ? chalk.bold.underline : (str: string) => str;
+
+    const exportsStr = this.exports.map((m) => `* ${m.toString(options)}`).join('\n');
+    return `${boldUnderline(this.namespace)}\n${exportsStr}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    if (!this.namespace)
+      throw new Error(
+        'toFullSignature() should not be called on a module without namespace; make sure this.flatExportsRecursively() is called'
+      );
+
+    const exportsSignatures = this.exports.map((m) => m.toFullSignature(options)).join('\n');
+
+    let signature = `${this.namespace}\n${exportsSignatures}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      exports: this.exports.map((member) => member.toObject()),
+      internals: this.internals.map((member) => member.toObject()),
+      namespace: this.namespace,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ModuleSchema {
+    const location = obj.location;
+    const exportNodes = (obj.exports || []).map((member: any) => SchemaRegistry.fromObject(member));
+    const internals = (obj.internals || []).map((member: any) => SchemaRegistry.fromObject(member));
+    const namespace = obj.namespace;
+    const module = new ModuleSchema(location, exportNodes, internals);
+    module.namespace = namespace;
+    return module;
+  }
+}

package/schemas/named-tuple.ts

@@ -0,0 +1,39 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class NamedTupleSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly type: SchemaNode,
+    readonly name?: string
+  ) {
+    super();
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }): string {
+    return `${this.name}: ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `${this.name}: ${this.type.toFullSignature(options)}`;
+  }
+
+  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/object-literal-expression.ts

@@ -0,0 +1,42 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class ObjectLiteralExpressionSchema extends SchemaNode {
+  constructor(
+    readonly members: SchemaNode[],
+    readonly location: SchemaLocation
+  ) {
+    super();
+  }
+
+  getNodes() {
+    return this.members;
+  }
+
+  toString(options?: { color?: boolean }): string {
+    return `{\n${this.members.map((member) => `\t${member.toString(options)}`).join('\n')}\n}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const membersStr = this.members.map((member) => member.toFullSignature(options)).join(',\n');
+
+    return `{\n${membersStr
+      .split('\n')
+      .map((line) => `  ${line}`)
+      .join('\n')}\n}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      members: this.members.map((element) => element.toObject()),
+      location: this.location,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): ObjectLiteralExpressionSchema {
+    const members = obj.members.map((member) => SchemaRegistry.fromObject(member));
+    const location = obj.location;
+    return new ObjectLiteralExpressionSchema(members, location);
+  }
+}

package/schemas/parameter.ts

@@ -0,0 +1,104 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class ParameterSchema<T extends SchemaNode = SchemaNode> extends SchemaNode {
+  readonly type: T;
+  readonly objectBindingNodes?: SchemaNode[];
+
+  getNodes(): SchemaNode[] {
+    return [this.type, ...(this.objectBindingNodes || [])];
+  }
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    type: T,
+    readonly isOptional: boolean,
+    readonly defaultValue?: any,
+    readonly description?: string,
+    objectBindingNodes?: SchemaNode[],
+    readonly isSpread: boolean = false
+  ) {
+    super();
+    this.type = type;
+    this.objectBindingNodes = objectBindingNodes;
+  }
+
+  toString() {
+    return `${this.name}${this.isOptional ? '?' : ''}: ${this.type.toString()}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let paramStr = '';
+
+    if (options?.showDocs && this.description) {
+      paramStr += `/** ${this.description} */\n`;
+    }
+
+    if (this.isSpread) {
+      paramStr += '...';
+    }
+
+    let paramName = '';
+
+    if (this.objectBindingNodes && this.objectBindingNodes.length > 0) {
+      const bindingsStr = this.objectBindingNodes.map((node) => node.toFullSignature(options)).join(', ');
+      paramName += `{ ${bindingsStr} }`;
+    } else {
+      paramName += this.name;
+    }
+
+    if (this.isOptional) {
+      paramName += '?';
+    }
+
+    paramStr += `${paramName}`;
+
+    if (this.type && typeof this.type.toString === 'function') {
+      const typeName = this.type.toString();
+      if (typeName) {
+        paramStr += `: ${typeName}`;
+      }
+    }
+
+    if (this.defaultValue !== undefined) {
+      paramStr += ` = ${this.defaultValue}`;
+    }
+
+    return paramStr;
+  }
+
+  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

@@ -0,0 +1,42 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+/**
+ * type inside parentheses
+ * e.g. (T1 | T2)
+ */
+export class ParenthesizedTypeSchema extends SchemaNode {
+  readonly type: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    type: SchemaNode
+  ) {
+    super();
+    this.type = type;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }): string {
+    return `(${this.type.toString(options)})`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `(${this.type.toFullSignature(options)})`;
+  }
+
+  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/property-assignment.ts

@@ -0,0 +1,50 @@
+import { SchemaNode, SchemaLocation } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+import { DocSchema } from './docs';
+
+export class PropertyAssignmentSchema extends SchemaNode {
+  constructor(
+    readonly name: string,
+    readonly value: SchemaNode,
+    readonly location: SchemaLocation,
+    readonly doc?: DocSchema
+  ) {
+    super();
+  }
+
+  toString(options?: { color?: boolean }): string {
+    return `${this.name}: ${this.value.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let result = '';
+
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+
+    const valueStr = this.value.toFullSignature(options);
+
+    result += `${this.name}: ${valueStr}`;
+
+    return result;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      value: this.value.toObject(),
+      doc: this.doc?.toObject(),
+      location: this.location,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): PropertyAssignmentSchema {
+    const name = obj.name;
+    const value = SchemaRegistry.fromObject(obj.value);
+    const location = obj.location;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new PropertyAssignmentSchema(name, value, location, doc);
+  }
+}

package/schemas/set-accessor.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { ParameterSchema } from './parameter';
+
+export class SetAccessorSchema extends SchemaNode {
+  readonly param: ParameterSchema;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    param: ParameterSchema,
+    readonly signature: string
+  ) {
+    super();
+    this.param = param;
+  }
+
+  getSignature() {
+    return this.signature;
+  }
+
+  toString() {
+    return `set ${chalk.bold(this.name)}(${this.param.toString()})`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const paramStr = this.param.toFullSignature(options);
+    return `set ${this.name}(${paramStr})`;
+  }
+
+  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

@@ -0,0 +1,42 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TemplateLiteralTypeSpanSchema extends SchemaNode {
+  type: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly literal: string,
+    type: SchemaNode
+  ) {
+    super();
+    this.type = type;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }) {
+    return `${this.type.toString(options)} ${this.literal}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `${this.type.toFullSignature(options)} ${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

@@ -0,0 +1,40 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { TemplateLiteralTypeSpanSchema } from './template-literal-type-span';
+
+export class TemplateLiteralTypeSchema extends SchemaNode {
+  readonly templateSpans: TemplateLiteralTypeSpanSchema[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly head: string,
+    templateSpans: TemplateLiteralTypeSpanSchema[]
+  ) {
+    super();
+    this.templateSpans = templateSpans;
+  }
+
+  toString(options?: { color?: boolean }) {
+    const spans = this.templateSpans.map((span) => span.toString(options)).join('');
+    return `${this.head}${spans}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const spans = this.templateSpans.map((span) => span.toFullSignature(options)).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

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

package/schemas/tuple-type.ts

@@ -0,0 +1,35 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TupleTypeSchema extends SchemaNode {
+  readonly elements: SchemaNode[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    elements: SchemaNode[]
+  ) {
+    super();
+    this.elements = elements;
+  }
+
+  toString(options?: { color?: boolean }) {
+    return `[${this.elements.map((elem) => elem.toString(options)).join(', ')}]`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `[${this.elements.map((elem) => elem.toFullSignature(options)).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);
+  }
+}