@teambit/semantics.entities.semantic-schema 0.0.65 → 0.0.67

package/schemas/class.ts

@@ -16,7 +16,8 @@ export class ClassSchema extends SchemaNode {
     doc?: DocSchema,
     readonly typeParams?: string[],
     readonly extendsNodes?: ExpressionWithTypeArgumentsSchema[],
-    readonly implementNodes?: ExpressionWithTypeArgumentsSchema[]
+    readonly implementNodes?: ExpressionWithTypeArgumentsSchema[],
+    readonly decorators?: SchemaNode[]
   ) {
     super();
     this.members = members;
@@ -29,7 +30,8 @@ export class ClassSchema extends SchemaNode {
 
   toString() {
     const membersStr = this.members.map((m) => `* ${m.toString()}`).join('\n');
-    return `${chalk.bold.underline(this.name)}\n${membersStr}`;
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString()).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${chalk.bold.underline(this.name)}\n${membersStr}`;
   }
 
   toObject() {
@@ -42,6 +44,7 @@ export class ClassSchema extends SchemaNode {
       typeParams: this.typeParams,
       extendsNodes: this.extendsNodes?.map((node) => node.toObject()),
       implementNodes: this.implementNodes?.map((node) => node.toObject()),
+      decorators: this.decorators?.map((decorator) => decorator.toObject()),
     };
   }
 
@@ -54,6 +57,17 @@ export class ClassSchema extends SchemaNode {
     const typeParams = obj.typeParams;
     const extendsNodes = obj.extendsNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
     const implementNodes = obj.implementNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));
-    return new ClassSchema(name, members, location, signature, doc, typeParams, extendsNodes, implementNodes);
+    const decorators = obj.decorators?.map((decorator: any) => SchemaRegistry.fromObject(decorator));
+    return new ClassSchema(
+      name,
+      members,
+      location,
+      signature,
+      doc,
+      typeParams,
+      extendsNodes,
+      implementNodes,
+      decorators
+    );
   }
 }

package/schemas/decorator.ts

@@ -0,0 +1,41 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { SchemaRegistry } from '../schema-registry';
+import { DocSchema } from './docs';
+
+export class DecoratorSchema extends SchemaNode {
+  constructor(
+    readonly location: SchemaLocation,
+    readonly name: string,
+    readonly doc?: DocSchema,
+    readonly args?: SchemaNode[]
+  ) {
+    super();
+  }
+
+  getNodes() {
+    return this.args || [];
+  }
+
+  toString() {
+    // name and args
+    const argsStr = this.args?.map((arg) => arg.toString()).join(', ');
+    return `@${this.name}${argsStr ? `(${argsStr})` : ''}`;
+  }
+
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      doc: this.doc?.toObject(),
+      args: this.args?.map((arg) => arg.toObject()),
+    };
+  }
+
+  static fromObject(obj: Record<string, any>): DecoratorSchema {
+    const location = obj.location;
+    const name = obj.name;
+    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;
+    const args = obj.args ? obj.args.map((arg) => SchemaRegistry.fromObject(arg)) : undefined;
+    return new DecoratorSchema(location, name, doc, args);
+  }
+}

package/schemas/function-like.ts

@@ -33,7 +33,8 @@ export class FunctionLikeSchema extends SchemaNode {
     signature: string,
     readonly modifiers: Modifier[] = [],
     doc?: DocSchema,
-    readonly typeParams?: string[] // generics e.g. <T>myFunction
+    readonly typeParams?: string[],
+    readonly decorators?: SchemaNode[]
   ) {
     super();
     this.params = params;
@@ -43,13 +44,14 @@ export class FunctionLikeSchema extends SchemaNode {
   }
 
   getNodes() {
-    return [...this.params, this.returnType];
+    return [...this.params, this.returnType, ...(this.decorators || [])];
   }
 
   toString() {
     const paramsStr = this.params.map((param) => param.toString()).join(', ');
     const typeParamsStr = this.typeParams ? `<${this.typeParams.join(', ')}>` : '';
-    return `${this.modifiersToString()}${typeParamsStr}${chalk.bold(
+    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString()).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${this.modifiersToString()}${typeParamsStr}${chalk.bold(
       this.name
     )}(${paramsStr}): ${this.returnType.toString()}`;
   }
@@ -63,10 +65,15 @@ export class FunctionLikeSchema extends SchemaNode {
   }
 
   generateSignature(): string {
-    return FunctionLikeSchema.createSignature(this.name, this.params, this.returnType);
+    return FunctionLikeSchema.createSignature(this.name, this.params, this.returnType, this.decorators);
   }
 
-  static createSignature(name: string, params: ParameterSchema[], returnType: SchemaNode): string {
+  static createSignature(
+    name: string,
+    params: ParameterSchema[],
+    returnType: SchemaNode,
+    decorators?: SchemaNode[]
+  ): string {
     const paramsStr = params
       .map((param) => {
         let type = param.type.toString();
@@ -74,7 +81,8 @@ export class FunctionLikeSchema extends SchemaNode {
         return `${param.name}${param.isOptional ? '?' : ''}: ${type}`;
       })
       .join(', ');
-    return `${name}(${paramsStr}): ${returnType.toString()}`;
+    const decoratorsStr = decorators?.map((decorator) => decorator.toString()).join('\n');
+    return `${decorators ? `${decoratorsStr}\n` : ''}${name}(${paramsStr}): ${returnType.toString()}`;
   }
 
   toObject() {
@@ -87,6 +95,7 @@ export class FunctionLikeSchema extends SchemaNode {
       modifiers: this.modifiers,
       doc: this.doc?.toObject(),
       typeParams: this.typeParams,
+      decorators: this.decorators?.map((decorator) => decorator.toObject()),
     };
   }
 
@@ -99,7 +108,8 @@ export class FunctionLikeSchema extends SchemaNode {
       obj.signature,
       obj.modifiers,
       obj.doc ? DocSchema.fromObject(obj.doc) : undefined,
-      obj.typeParams
+      obj.typeParams,
+      obj.decorators?.map((decorator) => SchemaRegistry.fromObject(decorator))
     );
   }
 

package/schemas/index.ts

@@ -39,4 +39,9 @@ export { ConditionalTypeSchema } from './conditional-type';
 export { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';
 export { NamedTupleSchema } from './named-tuple';
 export { UnImplementedSchema } from './unimplemented-schema';
+export { ObjectLiteralExpressionSchema } from './object-literal-expression';
+export { ArrayLiteralExpressionSchema } from './array-literal-expression';
+export { PropertyAssignmentSchema } from './property-assignment';
+export { DecoratorSchema } from './decorator';
+export { LiteralValueSchema } from './literal-value';
 export * from './docs';

package/schemas/literal-value.ts

@@ -0,0 +1,25 @@
+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;
+  }
+
+  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/object-literal-expression.ts

@@ -0,0 +1,30 @@
+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(): string {
+    return `{\n${this.members.map((member) => `\t${member.toString()}`).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/property-assignment.ts

@@ -0,0 +1,36 @@
+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() {
+    return `${this.name}: ${this.value.toString()}`;
+  }
+
+  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/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "lib": [
+      "es2019",
+      "DOM",
+      "ES6",
+      "DOM.Iterable"
+    ],
+    "target": "es2015",
+    "module": "CommonJS",
+    "jsx": "react",
+    "allowJs": true,
+    "composite": true,
+    "declaration": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "rootDir": ".",
+    "resolveJsonModule": true
+  },
+  "exclude": [
+    "dist",
+    "package.json"
+  ],
+  "include": [
+    "**/*",
+    "**/*.json"
+  ]
+}

package/types/asset.d.ts

@@ -0,0 +1,29 @@
+declare module '*.png' {
+  const value: any;
+  export = value;
+}
+declare module '*.svg' {
+  import type { FunctionComponent, SVGProps } from 'react';
+
+  export const ReactComponent: FunctionComponent<SVGProps<SVGSVGElement> & { title?: string }>;
+  const src: string;
+  export default src;
+}
+
+// @TODO Gilad
+declare module '*.jpg' {
+  const value: any;
+  export = value;
+}
+declare module '*.jpeg' {
+  const value: any;
+  export = value;
+}
+declare module '*.gif' {
+  const value: any;
+  export = value;
+}
+declare module '*.bmp' {
+  const value: any;
+  export = value;
+}

package/types/style.d.ts

@@ -0,0 +1,42 @@
+declare module '*.module.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+declare module '*.module.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.less' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.css' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.sass' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.scss' {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module '*.mdx' {
+  const component: any;
+  export default component;
+}