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

package/schemas/type-array.ts

@@ -0,0 +1,39 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TypeArraySchema extends SchemaNode {
+  readonly type: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    type: SchemaNode
+  ) {
+    super();
+    this.type = type;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }) {
+    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>): TypeArraySchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new TypeArraySchema(location, type);
+  }
+}

package/schemas/type-intersection.ts

@@ -0,0 +1,39 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TypeIntersectionSchema extends SchemaNode {
+  readonly types: SchemaNode[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    types: SchemaNode[]
+  ) {
+    super();
+    this.types = types;
+  }
+
+  getNodes() {
+    return this.types;
+  }
+
+  toString(options?: { color?: boolean }) {
+    return `${this.types.map((type) => type.toString(options)).join(' & ')}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return this.types.map((type) => type.toFullSignature(options)).join(' & ');
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      types: this.types.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeIntersectionSchema {
+    const location = obj.location;
+    const types = obj.types.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeIntersectionSchema(location, types);
+  }
+}

package/schemas/type-literal.ts

@@ -0,0 +1,60 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+/**
+ * e.g. `{ a: string; b: number }`
+ */
+export class TypeLiteralSchema extends SchemaNode {
+  readonly members: SchemaNode[];
+
+  constructor(
+    readonly location: SchemaLocation,
+    members: SchemaNode[]
+  ) {
+    super();
+    this.members = members;
+  }
+
+  getNodes() {
+    return this.members;
+  }
+
+  toString() {
+    return `{ ${this.members.map((type) => type.toString()).join('; ')} }`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const indent = (level: number) => '  '.repeat(level);
+    const level = 0;
+    let signature = '';
+
+    signature += '{\n';
+
+    this.members.forEach((member) => {
+      const memberSignature = member.toFullSignature(options);
+
+      const memberLines = memberSignature.split('\n');
+
+      const indentedLines = memberLines.map((line) => indent(level + 1) + line);
+
+      signature += indentedLines.join('\n') + '\n';
+    });
+
+    signature += indent(level) + '}';
+
+    return signature;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      members: this.members.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeLiteralSchema {
+    const location = obj.location;
+    const members = obj.members.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeLiteralSchema(location, members);
+  }
+}

package/schemas/type-operator.ts

@@ -0,0 +1,41 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TypeOperatorSchema extends SchemaNode {
+  type: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    type: SchemaNode
+  ) {
+    super();
+    this.type = type;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toString(options?: { color?: boolean }) {
+    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>): TypeOperatorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = SchemaRegistry.fromObject(obj.type);
+    return new TypeOperatorSchema(location, name, type);
+  }
+}

package/schemas/type-predicate.ts

@@ -0,0 +1,64 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+/**
+ * e.g. `function f(str: any): str is string {}`
+ *
+ * example when the type is empty:
+ * ```ts
+ * function assert(condition: any, msg?: string): asserts condition {
+ *  if (!condition) {
+ *   throw new AssertionError(msg);
+ *  }
+ * }
+ * ```
+ *
+ */
+export class TypePredicateSchema extends SchemaNode {
+  readonly type?: SchemaNode;
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    type?: SchemaNode,
+    readonly hasAssertsModifier = false
+  ) {
+    super();
+    this.type = type;
+  }
+
+  toString(options?: { color?: boolean }) {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeStr = this.type ? ` is ${this.type.toString(options)}` : '';
+    return assertsKeyword + this.name + typeStr;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const assertsKeyword = this.hasAssertsModifier ? 'asserts ' : '';
+    const typeSignature = this.type ? ` is ${this.type.toFullSignature(options)}` : '';
+    let signature = `${assertsKeyword}${this.name}${typeSignature}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type?.toObject(),
+      hasAssertsModifier: this.hasAssertsModifier,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypePredicateSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = obj.type ? SchemaRegistry.fromObject(obj.type) : undefined;
+    const hasAssertsModifier = obj.hasAssertsModifier;
+    return new TypePredicateSchema(location, name, type, hasAssertsModifier);
+  }
+}

package/schemas/type-query.ts

@@ -0,0 +1,49 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+/**
+ * e.g. `typeof Foo`
+ */
+export class TypeQuerySchema extends SchemaNode {
+  readonly type: SchemaNode;
+
+  constructor(
+    readonly location: SchemaLocation,
+    type: SchemaNode,
+    readonly signature: string
+  ) {
+    super();
+    this.type = type;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  getSignature() {
+    return this.signature;
+  }
+
+  toString(options?: { color?: boolean }) {
+    return `typeof ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    return `typeof ${this.type.toFullSignature(options)}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      type: this.type.toObject(),
+      signature: this.signature,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeQuerySchema {
+    const location = obj.location;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const signature = obj.signature;
+    return new TypeQuerySchema(location, type, signature);
+  }
+}

package/schemas/type-ref.ts

@@ -0,0 +1,143 @@
+import { ComponentID } from '@teambit/component';
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export type PlainTypeRefSchema = {
+  name: string;
+  componentId?: string;
+  packageName?: string;
+};
+
+/**
+ * can be one of the following:
+ * 1. a reference to another "export" in the same component
+ * 2  a reference to another declaration in the same file (internal)
+ * 3. a reference to another component.
+ * 4. a reference to a package.
+ */
+export class TypeRefSchema extends SchemaNode {
+  /**
+   *  optional type arguments, e.g. type Foo = Bar<X, Y>. The X and Y are type arguments.
+   */
+  typeArgs?: SchemaNode[];
+
+  readonly componentId?: ComponentID;
+
+  constructor(
+    readonly location: SchemaLocation,
+    /**
+     * name of the reference to type.
+     */
+    readonly name: string,
+    /**
+     * target component id. existing if the type is defined in another component.
+     */
+    componentId?: ComponentID,
+    /**
+     * target package name. existing if type is defined in different package.
+     */
+    readonly packageName?: string,
+    /**
+     * if the reference is not exported from the component, it can be internal to the file.
+     */
+    readonly internalFilePath?: string
+  ) {
+    super();
+    this.componentId = componentId;
+  }
+
+  getNodes(): SchemaNode[] {
+    return this.typeArgs || [];
+  }
+
+  withTypeArgs(typeArgs: SchemaNode[]) {
+    this.typeArgs = typeArgs;
+    return this;
+  }
+
+  toString(options?: { color?: boolean }) {
+    const name = this.nameToString(options);
+    if (!this.typeArgs) {
+      return name;
+    }
+    const args = this.typeArgs.map((arg) => arg.toString(options)).join(', ');
+    return `${name}<${args}>`;
+  }
+
+  private nameToString(options?: { color?: boolean }) {
+    const dim = options?.color ? chalk.dim : (str: string) => str;
+    if (this.componentId) {
+      const compStr = dim(`(component: ${this.componentId.toStringWithoutVersion()})`);
+      return `${compStr} ${this.name}`;
+    }
+    if (this.packageName) {
+      const pkgStr = dim(`(package: ${this.packageName})`);
+      return `${pkgStr} ${this.name}`;
+    }
+    return this.name;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    let signature = this.name;
+
+    if (this.typeArgs && this.typeArgs.length > 0) {
+      const argsSignatures = this.typeArgs.map((arg) => arg.toFullSignature(options)).join(', ');
+      signature += `<${argsSignatures}>`;
+    }
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
+  /**
+   * whether this type was already exported in this component
+   */
+  isFromThisComponent() {
+    return !this.componentId && !this.packageName;
+  }
+
+  /**
+   * whether this type is internal to the file.
+   */
+  isInternalReference() {
+    return !!this.internalFilePath && this.isFromThisComponent();
+  }
+
+  /**
+   * whether this type is exported from this component.
+   */
+  isExported() {
+    return this.isFromThisComponent() && !this.isInternalReference();
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      componentId: this.componentId ? this.componentId.toObject() : undefined,
+      packageName: this.packageName,
+      internalFilePath: this.internalFilePath,
+      typeArgs: this.typeArgs?.map((type) => type.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeRefSchema {
+    const location = obj.location;
+    const name = obj.name;
+    let componentId;
+    try {
+      componentId = obj.componentId ? ComponentID.fromObject(obj.componentId) : undefined;
+    } catch {
+      componentId = undefined;
+    }
+    const packageName = obj.packageName;
+    const internalFilePath = obj.internalFilePath;
+    const typeArgs = obj.typeArgs?.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeRefSchema(location, name, componentId, packageName, internalFilePath).withTypeArgs(typeArgs);
+  }
+}

package/schemas/type-union.ts

@@ -0,0 +1,41 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TypeUnionSchema extends SchemaNode {
+  readonly types: SchemaNode[];
+  constructor(
+    readonly location: SchemaLocation,
+    types: SchemaNode[]
+  ) {
+    super();
+    this.types = types;
+  }
+  toString(options?: { color?: boolean }) {
+    return `${this.types.map((type) => type.toString(options)).join(' | ')}`;
+  }
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeSignatures = this.types.map((type) => type.toFullSignature(options));
+    let signature = typeSignatures.join(' | ');
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+  getNodes() {
+    return this.types;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      types: this.types.map((type) => type.toObject()),
+    };
+  }
+  static fromObject(obj: Record<string, any>): TypeUnionSchema {
+    const location = obj.location;
+    const types = obj.types.map((type: any) => SchemaRegistry.fromObject(type));
+    return new TypeUnionSchema(location, types);
+  }
+}

package/schemas/type.ts

@@ -0,0 +1,61 @@
+import chalk from 'chalk';
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+import { SchemaRegistry } from '../schema-registry';
+
+export class TypeSchema extends SchemaNode {
+  readonly type: SchemaNode;
+  readonly doc?: DocSchema;
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    type: SchemaNode,
+    readonly signature: string,
+    doc?: DocSchema
+  ) {
+    super();
+    this.type = type;
+    this.doc = doc;
+  }
+
+  toString(options?: { color?: boolean }) {
+    const bold = options?.color ? chalk.bold : (str: string) => str;
+    return `type ${bold(this.name)}: ${this.type.toString(options)}`;
+  }
+
+  toFullSignature(options?: { showDocs?: boolean }): string {
+    const typeSignature = this.type.toFullSignature(options);
+
+    let signature = `type ${this.name}: ${typeSignature}`;
+
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+
+    return signature;
+  }
+
+  getNodes() {
+    return [this.type];
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      type: this.type.toObject(),
+      signature: this.signature,
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): TypeSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const type = SchemaRegistry.fromObject(obj.type);
+    const signature = obj.signature;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    return new TypeSchema(location, name, type, signature, doc);
+  }
+}

package/schemas/unimplemented-schema.ts

@@ -0,0 +1,35 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+export class UnImplementedSchema extends SchemaNode {
+  readonly displaySchemaName = 'Unimplemented Schemas';
+
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly type: string
+  ) {
+    super();
+  }
+
+  toString() {
+    return `<<unimplemented schema ${this.name} of type ${this.type}>>`;
+  }
+
+  toFullSignature(): string {
+    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

@@ -0,0 +1,38 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+
+/**
+ * needed for better backward and forward compatibility.
+ * in case a previous version of the semantic-schema had a schema class that doesn't exist anymore, then it'll be
+ * wrapped in this class.
+ */
+export class UnknownSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly schemaObj: Record<string, any>
+  ) {
+    super();
+  }
+
+  toString() {
+    return `<<unknown schema ${this.name}>>`;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  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

@@ -0,0 +1,32 @@
+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: SchemaLocation,
+    readonly name: string
+  ) {
+    super();
+  }
+
+  toString() {
+    return this.name;
+  }
+
+  toFullSignature(): string {
+    return this.toString();
+  }
+
+  toObject() {
+    return super.toObject();
+  }
+
+  static fromObject(obj: Record<string, any>): UnresolvedSchema {
+    const location = obj.location;
+    const name = obj.name;
+    return new UnresolvedSchema(location, name);
+  }
+}