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

package/dist/schema-node.d.ts

@@ -0,0 +1,51 @@
+import { DocSchema } from './schemas';
+export interface ISchemaNode {
+    __schema: string;
+    location: SchemaLocation;
+    doc?: DocSchema;
+    signature?: string;
+    name?: string;
+    toObject(): Record<string, any>;
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    getNodes(): SchemaNode[];
+    findNode(predicate: (node: SchemaNode) => boolean, visitedNodes?: Set<SchemaNode>): SchemaNode | undefined;
+    getAllNodesRecursively(visitedNodes?: Set<SchemaNode>): SchemaNode[];
+    displaySchemaName: string;
+}
+/**
+ * a convenient abstract class for all schema to extend.
+ * the reason for having it as an abstract class and not an interface, for now, is mostly for the `__schema` prop.
+ * this way it won't need to be implemented in each one of the subclasses.
+ */
+export declare abstract class SchemaNode implements ISchemaNode {
+    readonly __schema: string;
+    readonly displaySchemaName: string;
+    abstract readonly location: SchemaLocation;
+    readonly doc?: DocSchema;
+    readonly signature?: string;
+    readonly name?: string;
+    static fromObject(obj: Record<string, any>): SchemaNode;
+    toObject(): Record<string, any>;
+    abstract toString(options?: {
+        color?: boolean;
+    }): string;
+    abstract toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    getNodes(): SchemaNode[];
+    getAllNodesRecursively(visitedNodes?: Set<SchemaNode>): SchemaNode[];
+    findNode(predicate: (node: SchemaNode) => boolean, visitedNodes?: Set<SchemaNode>): SchemaNode | undefined;
+}
+export type SchemaLocation = {
+    /**
+     * file-path relative to the component root-dir. normalized to Linux.
+     */
+    filePath: string;
+    line: number;
+    character: number;
+};

package/dist/schema-node.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SchemaNode = void 0;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _pluralize() {
+  const data = _interopRequireDefault(require("pluralize"));
+  _pluralize = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * a convenient abstract class for all schema to extend.
+ * the reason for having it as an abstract class and not an interface, for now, is mostly for the `__schema` prop.
+ * this way it won't need to be implemented in each one of the subclasses.
+ */
+class SchemaNode {
+  __schema = this.constructor.name;
+  displaySchemaName = (0, _pluralize().default)(this.constructor.name.replace(/Schema$/, '').replace(/([A-Z])/g, ' $1').trim());
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static fromObject(obj) {
+    throw new Error(`Method 'fromObject' not implemented in subclass.`);
+  }
+  toObject() {
+    return (0, _lodash().pickBy)({
+      __schema: this.__schema,
+      location: this.location,
+      doc: this.doc ? this.doc.toObject() : undefined,
+      signature: this.signature,
+      name: this.name
+    }, v => v !== undefined);
+  }
+  getNodes() {
+    return [this];
+  }
+  getAllNodesRecursively(visitedNodes = new Set()) {
+    if (visitedNodes.has(this)) {
+      return [];
+    }
+    visitedNodes.add(this);
+    const nodes = this.getNodes();
+    return [this, ...nodes.flatMap(node => node.getAllNodesRecursively(visitedNodes))];
+  }
+  findNode(predicate, visitedNodes = new Set()) {
+    if (predicate(this)) return this;
+    if (visitedNodes.has(this)) return undefined;
+    visitedNodes.add(this);
+    for (const child of this.getNodes()) {
+      const foundNode = child.findNode(predicate, visitedNodes);
+      if (foundNode) return foundNode;
+    }
+    return undefined;
+  }
+}
+exports.SchemaNode = SchemaNode;
+
+//# sourceMappingURL=schema-node.js.map

package/dist/schema-node.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lodash","data","require","_pluralize","_interopRequireDefault","e","__esModule","default","SchemaNode","__schema","constructor","name","displaySchemaName","pluralize","replace","trim","fromObject","obj","Error","toObject","pickBy","location","doc","undefined","signature","v","getNodes","getAllNodesRecursively","visitedNodes","Set","has","add","nodes","flatMap","node","findNode","predicate","child","foundNode","exports"],"sources":["schema-node.ts"],"sourcesContent":["import { pickBy } from 'lodash';\nimport pluralize from 'pluralize';\nimport { DocSchema } from './schemas';\n\nexport interface ISchemaNode {\n  __schema: string;\n  location: SchemaLocation;\n  doc?: DocSchema;\n  signature?: string;\n  name?: string;\n  toObject(): Record<string, any>;\n  toString(options?: { color?: boolean }): string;\n  toFullSignature(options?: { showDocs?: boolean }): string;\n  getNodes(): SchemaNode[];\n  findNode(predicate: (node: SchemaNode) => boolean, visitedNodes?: Set<SchemaNode>): SchemaNode | undefined;\n  getAllNodesRecursively(visitedNodes?: Set<SchemaNode>): SchemaNode[];\n  displaySchemaName: string;\n}\n\n/**\n * a convenient abstract class for all schema to extend.\n * the reason for having it as an abstract class and not an interface, for now, is mostly for the `__schema` prop.\n * this way it won't need to be implemented in each one of the subclasses.\n */\nexport abstract class SchemaNode implements ISchemaNode {\n  readonly __schema = this.constructor.name;\n  readonly displaySchemaName = pluralize(\n    this.constructor.name\n      .replace(/Schema$/, '')\n      .replace(/([A-Z])/g, ' $1')\n      .trim()\n  );\n\n  abstract readonly location: SchemaLocation;\n  readonly doc?: DocSchema;\n  readonly signature?: string;\n  readonly name?: string;\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  static fromObject(obj: Record<string, any>): SchemaNode {\n    throw new Error(`Method 'fromObject' not implemented in subclass.`);\n  }\n\n  toObject(): Record<string, any> {\n    return pickBy(\n      {\n        __schema: this.__schema,\n        location: this.location,\n        doc: this.doc ? this.doc.toObject() : undefined,\n        signature: this.signature,\n        name: this.name,\n      },\n      (v) => v !== undefined\n    );\n  }\n\n  abstract toString(options?: { color?: boolean }): string;\n  abstract toFullSignature(options?: { showDocs?: boolean }): string;\n\n  getNodes(): SchemaNode[] {\n    return [this];\n  }\n\n  getAllNodesRecursively(visitedNodes = new Set<SchemaNode>()): SchemaNode[] {\n    if (visitedNodes.has(this)) {\n      return [];\n    }\n\n    visitedNodes.add(this);\n\n    const nodes = this.getNodes();\n    return [this, ...nodes.flatMap((node) => node.getAllNodesRecursively(visitedNodes))];\n  }\n\n  findNode(predicate: (node: SchemaNode) => boolean, visitedNodes = new Set<SchemaNode>()): SchemaNode | undefined {\n    if (predicate(this)) return this;\n    if (visitedNodes.has(this)) return undefined;\n\n    visitedNodes.add(this);\n\n    for (const child of this.getNodes()) {\n      const foundNode = child.findNode(predicate, visitedNodes);\n      if (foundNode) return foundNode;\n    }\n\n    return undefined;\n  }\n}\n\nexport type SchemaLocation = {\n  /**\n   * file-path relative to the component root-dir. normalized to Linux.\n   */\n  filePath: string;\n  line: number;\n  character: number;\n};\n"],"mappings":";;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,WAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,UAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAkC,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAkBlC;AACA;AACA;AACA;AACA;AACO,MAAeG,UAAU,CAAwB;EAC7CC,QAAQ,GAAG,IAAI,CAACC,WAAW,CAACC,IAAI;EAChCC,iBAAiB,GAAG,IAAAC,oBAAS,EACpC,IAAI,CAACH,WAAW,CAACC,IAAI,CAClBG,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CACtBA,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,CAC1BC,IAAI,CAAC,CACV,CAAC;EAMD;EACA,OAAOC,UAAUA,CAACC,GAAwB,EAAc;IACtD,MAAM,IAAIC,KAAK,CAAC,kDAAkD,CAAC;EACrE;EAEAC,QAAQA,CAAA,EAAwB;IAC9B,OAAO,IAAAC,gBAAM,EACX;MACEX,QAAQ,EAAE,IAAI,CAACA,QAAQ;MACvBY,QAAQ,EAAE,IAAI,CAACA,QAAQ;MACvBC,GAAG,EAAE,IAAI,CAACA,GAAG,GAAG,IAAI,CAACA,GAAG,CAACH,QAAQ,CAAC,CAAC,GAAGI,SAAS;MAC/CC,SAAS,EAAE,IAAI,CAACA,SAAS;MACzBb,IAAI,EAAE,IAAI,CAACA;IACb,CAAC,EACAc,CAAC,IAAKA,CAAC,KAAKF,SACf,CAAC;EACH;EAKAG,QAAQA,CAAA,EAAiB;IACvB,OAAO,CAAC,IAAI,CAAC;EACf;EAEAC,sBAAsBA,CAACC,YAAY,GAAG,IAAIC,GAAG,CAAa,CAAC,EAAgB;IACzE,IAAID,YAAY,CAACE,GAAG,CAAC,IAAI,CAAC,EAAE;MAC1B,OAAO,EAAE;IACX;IAEAF,YAAY,CAACG,GAAG,CAAC,IAAI,CAAC;IAEtB,MAAMC,KAAK,GAAG,IAAI,CAACN,QAAQ,CAAC,CAAC;IAC7B,OAAO,CAAC,IAAI,EAAE,GAAGM,KAAK,CAACC,OAAO,CAAEC,IAAI,IAAKA,IAAI,CAACP,sBAAsB,CAACC,YAAY,CAAC,CAAC,CAAC;EACtF;EAEAO,QAAQA,CAACC,SAAwC,EAAER,YAAY,GAAG,IAAIC,GAAG,CAAa,CAAC,EAA0B;IAC/G,IAAIO,SAAS,CAAC,IAAI,CAAC,EAAE,OAAO,IAAI;IAChC,IAAIR,YAAY,CAACE,GAAG,CAAC,IAAI,CAAC,EAAE,OAAOP,SAAS;IAE5CK,YAAY,CAACG,GAAG,CAAC,IAAI,CAAC;IAEtB,KAAK,MAAMM,KAAK,IAAI,IAAI,CAACX,QAAQ,CAAC,CAAC,EAAE;MACnC,MAAMY,SAAS,GAAGD,KAAK,CAACF,QAAQ,CAACC,SAAS,EAAER,YAAY,CAAC;MACzD,IAAIU,SAAS,EAAE,OAAOA,SAAS;IACjC;IAEA,OAAOf,SAAS;EAClB;AACF;AAACgB,OAAA,CAAA/B,UAAA,GAAAA,UAAA","ignoreList":[]}

package/dist/schema-registry.d.ts

@@ -0,0 +1,17 @@
+import { SchemaNodeConstructor } from './schema-node-constructor';
+type GetSchemaFunc = () => SchemaNodeConstructor[];
+export declare class SchemaRegistry {
+    private static instance;
+    private _schemas;
+    private _getSchemas;
+    private constructor();
+    static registerGetSchemas(getSchemas: GetSchemaFunc): void;
+    /**
+     * @deprecated use registerGetSchemas instead
+     * registerGetSchemas is better for performance as it lazy-loads the schemas.
+     */
+    static register(schema: SchemaNodeConstructor): void;
+    static schemas(): Record<string, SchemaNodeConstructor>;
+    static fromObject(obj: Record<string, any>): any;
+}
+export {};

package/dist/schema-registry.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SchemaRegistry = void 0;
+function _unknownSchemaFactory() {
+  const data = require("./unknown-schema-factory");
+  _unknownSchemaFactory = function () {
+    return data;
+  };
+  return data;
+}
+class SchemaRegistry {
+  static instance = new SchemaRegistry();
+  _getSchemas = [];
+  constructor() {
+    this._schemas = {};
+  }
+  static registerGetSchemas(getSchemas) {
+    this.instance._getSchemas.push(getSchemas);
+  }
+
+  /**
+   * @deprecated use registerGetSchemas instead
+   * registerGetSchemas is better for performance as it lazy-loads the schemas.
+   */
+  static register(schema) {
+    if (this.instance._schemas[schema.name]) return;
+    this.instance._schemas[schema.name] = schema;
+  }
+  static schemas() {
+    // this happens only once. as soon as the function is called, it registers all the schemas.
+    this.instance._getSchemas.forEach(getSchemas => {
+      const schemas = getSchemas();
+      schemas.forEach(schema => {
+        if (this.instance._schemas[schema.name]) return;
+        this.instance._schemas[schema.name] = schema;
+      });
+    });
+    this.instance._getSchemas = [];
+    return this.instance._schemas;
+  }
+  static fromObject(obj) {
+    if (!obj.__schema) {
+      throw new Error(`fatal: "__schema" is missing, make sure the transformer is set on SchemaNode type`);
+    }
+    const schemas = this.schemas();
+    const SchemaClass = schemas[obj.__schema];
+    if (!SchemaClass) {
+      // for backward and forward compatibility, to not break the users, it's better to return an unknown schema than throwing.
+      return _unknownSchemaFactory().UnknownSchemaFactory.create(obj.location || {
+        path: '',
+        line: 0,
+        character: 0
+      }, obj.__schema, obj);
+    }
+    return SchemaClass.fromObject(obj);
+  }
+}
+exports.SchemaRegistry = SchemaRegistry;
+
+//# sourceMappingURL=schema-registry.js.map

package/dist/schema-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_unknownSchemaFactory","data","require","SchemaRegistry","instance","_getSchemas","constructor","_schemas","registerGetSchemas","getSchemas","push","register","schema","name","schemas","forEach","fromObject","obj","__schema","Error","SchemaClass","UnknownSchemaFactory","create","location","path","line","character","exports"],"sources":["schema-registry.ts"],"sourcesContent":["import { SchemaNodeConstructor } from './schema-node-constructor';\nimport { UnknownSchemaFactory } from './unknown-schema-factory';\n\ntype GetSchemaFunc = () => SchemaNodeConstructor[];\n\nexport class SchemaRegistry {\n  private static instance = new SchemaRegistry();\n  private _schemas: Record<string, SchemaNodeConstructor>;\n  private _getSchemas: GetSchemaFunc[] = [];\n\n  private constructor() {\n    this._schemas = {};\n  }\n\n  static registerGetSchemas(getSchemas: GetSchemaFunc) {\n    this.instance._getSchemas.push(getSchemas);\n  }\n\n  /**\n   * @deprecated use registerGetSchemas instead\n   * registerGetSchemas is better for performance as it lazy-loads the schemas.\n   */\n  static register(schema: SchemaNodeConstructor) {\n    if (this.instance._schemas[schema.name]) return;\n    this.instance._schemas[schema.name] = schema;\n  }\n\n  static schemas() {\n    // this happens only once. as soon as the function is called, it registers all the schemas.\n    this.instance._getSchemas.forEach((getSchemas) => {\n      const schemas = getSchemas();\n      schemas.forEach((schema) => {\n        if (this.instance._schemas[schema.name]) return;\n        this.instance._schemas[schema.name] = schema;\n      });\n    });\n    this.instance._getSchemas = [];\n    return this.instance._schemas;\n  }\n\n  static fromObject(obj: Record<string, any>) {\n    if (!obj.__schema) {\n      throw new Error(`fatal: \"__schema\" is missing, make sure the transformer is set on SchemaNode type`);\n    }\n    const schemas = this.schemas();\n    const SchemaClass = schemas[obj.__schema];\n    if (!SchemaClass) {\n      // for backward and forward compatibility, to not break the users, it's better to return an unknown schema than throwing.\n      return UnknownSchemaFactory.create(obj.location || { path: '', line: 0, character: 0 }, obj.__schema, obj);\n    }\n    return SchemaClass.fromObject(obj);\n  }\n}\n"],"mappings":";;;;;;AACA,SAAAA,sBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,qBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIO,MAAME,cAAc,CAAC;EAC1B,OAAeC,QAAQ,GAAG,IAAID,cAAc,CAAC,CAAC;EAEtCE,WAAW,GAAoB,EAAE;EAEjCC,WAAWA,CAAA,EAAG;IACpB,IAAI,CAACC,QAAQ,GAAG,CAAC,CAAC;EACpB;EAEA,OAAOC,kBAAkBA,CAACC,UAAyB,EAAE;IACnD,IAAI,CAACL,QAAQ,CAACC,WAAW,CAACK,IAAI,CAACD,UAAU,CAAC;EAC5C;;EAEA;AACF;AACA;AACA;EACE,OAAOE,QAAQA,CAACC,MAA6B,EAAE;IAC7C,IAAI,IAAI,CAACR,QAAQ,CAACG,QAAQ,CAACK,MAAM,CAACC,IAAI,CAAC,EAAE;IACzC,IAAI,CAACT,QAAQ,CAACG,QAAQ,CAACK,MAAM,CAACC,IAAI,CAAC,GAAGD,MAAM;EAC9C;EAEA,OAAOE,OAAOA,CAAA,EAAG;IACf;IACA,IAAI,CAACV,QAAQ,CAACC,WAAW,CAACU,OAAO,CAAEN,UAAU,IAAK;MAChD,MAAMK,OAAO,GAAGL,UAAU,CAAC,CAAC;MAC5BK,OAAO,CAACC,OAAO,CAAEH,MAAM,IAAK;QAC1B,IAAI,IAAI,CAACR,QAAQ,CAACG,QAAQ,CAACK,MAAM,CAACC,IAAI,CAAC,EAAE;QACzC,IAAI,CAACT,QAAQ,CAACG,QAAQ,CAACK,MAAM,CAACC,IAAI,CAAC,GAAGD,MAAM;MAC9C,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,IAAI,CAACR,QAAQ,CAACC,WAAW,GAAG,EAAE;IAC9B,OAAO,IAAI,CAACD,QAAQ,CAACG,QAAQ;EAC/B;EAEA,OAAOS,UAAUA,CAACC,GAAwB,EAAE;IAC1C,IAAI,CAACA,GAAG,CAACC,QAAQ,EAAE;MACjB,MAAM,IAAIC,KAAK,CAAC,mFAAmF,CAAC;IACtG;IACA,MAAML,OAAO,GAAG,IAAI,CAACA,OAAO,CAAC,CAAC;IAC9B,MAAMM,WAAW,GAAGN,OAAO,CAACG,GAAG,CAACC,QAAQ,CAAC;IACzC,IAAI,CAACE,WAAW,EAAE;MAChB;MACA,OAAOC,4CAAoB,CAACC,MAAM,CAACL,GAAG,CAACM,QAAQ,IAAI;QAAEC,IAAI,EAAE,EAAE;QAAEC,IAAI,EAAE,CAAC;QAAEC,SAAS,EAAE;MAAE,CAAC,EAAET,GAAG,CAACC,QAAQ,EAAED,GAAG,CAAC;IAC5G;IACA,OAAOG,WAAW,CAACJ,UAAU,CAACC,GAAG,CAAC;EACpC;AACF;AAACU,OAAA,CAAAxB,cAAA,GAAAA,cAAA","ignoreList":[]}

package/dist/schemas/array-literal-expression.d.ts

@@ -0,0 +1,15 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+export declare class ArrayLiteralExpressionSchema extends SchemaNode {
+    readonly members: SchemaNode[];
+    readonly location: SchemaLocation;
+    constructor(members: SchemaNode[], location: SchemaLocation);
+    toObject(): {
+        members: Record<string, any>[];
+        location: SchemaLocation;
+    };
+    static fromObject(obj: Record<string, any>): ArrayLiteralExpressionSchema;
+    toString(): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+}

package/dist/schemas/array-literal-expression.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ArrayLiteralExpressionSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+class ArrayLiteralExpressionSchema extends _schemaNode().SchemaNode {
+  constructor(members, location) {
+    super();
+    this.members = members;
+    this.location = location;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      members: this.members.map(member => member.toObject()),
+      location: this.location
+    };
+  }
+  static fromObject(obj) {
+    const members = obj.members.map(member => _schemaRegistry().SchemaRegistry.fromObject(member));
+    return new ArrayLiteralExpressionSchema(members, obj.location);
+  }
+  toString() {
+    return `[${this.members.join(', ')}]`;
+  }
+  toFullSignature(options) {
+    const membersStr = this.members.map(member => member.toFullSignature(options)).join(', ');
+    return `[${membersStr}]`;
+  }
+}
+exports.ArrayLiteralExpressionSchema = ArrayLiteralExpressionSchema;
+
+//# sourceMappingURL=array-literal-expression.js.map

package/dist/schemas/array-literal-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","ArrayLiteralExpressionSchema","SchemaNode","constructor","members","location","toObject","map","member","fromObject","obj","SchemaRegistry","toString","join","toFullSignature","options","membersStr","exports"],"sources":["array-literal-expression.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class ArrayLiteralExpressionSchema extends SchemaNode {\n  constructor(\n    readonly members: SchemaNode[],\n    readonly location: SchemaLocation\n  ) {\n    super();\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      members: this.members.map((member) => member.toObject()),\n      location: this.location,\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): ArrayLiteralExpressionSchema {\n    const members = obj.members.map((member) => SchemaRegistry.fromObject(member));\n    return new ArrayLiteralExpressionSchema(members, obj.location);\n  }\n\n  toString(): string {\n    return `[${this.members.join(', ')}]`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    const membersStr = this.members.map((member) => member.toFullSignature(options)).join(', ');\n    return `[${membersStr}]`;\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,gBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,eAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAMG,4BAA4B,SAASC,wBAAU,CAAC;EAC3DC,WAAWA,CACAC,OAAqB,EACrBC,QAAwB,EACjC;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,OAAqB,GAArBA,OAAqB;IAAA,KACrBC,QAAwB,GAAxBA,QAAwB;EAGnC;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBF,OAAO,EAAE,IAAI,CAACA,OAAO,CAACG,GAAG,CAAEC,MAAM,IAAKA,MAAM,CAACF,QAAQ,CAAC,CAAC,CAAC;MACxDD,QAAQ,EAAE,IAAI,CAACA;IACjB,CAAC;EACH;EAEA,OAAOI,UAAUA,CAACC,GAAwB,EAAgC;IACxE,MAAMN,OAAO,GAAGM,GAAG,CAACN,OAAO,CAACG,GAAG,CAAEC,MAAM,IAAKG,gCAAc,CAACF,UAAU,CAACD,MAAM,CAAC,CAAC;IAC9E,OAAO,IAAIP,4BAA4B,CAACG,OAAO,EAAEM,GAAG,CAACL,QAAQ,CAAC;EAChE;EAEAO,QAAQA,CAAA,EAAW;IACjB,OAAO,IAAI,IAAI,CAACR,OAAO,CAACS,IAAI,CAAC,IAAI,CAAC,GAAG;EACvC;EAEAC,eAAeA,CAACC,OAAgC,EAAU;IACxD,MAAMC,UAAU,GAAG,IAAI,CAACZ,OAAO,CAACG,GAAG,CAAEC,MAAM,IAAKA,MAAM,CAACM,eAAe,CAACC,OAAO,CAAC,CAAC,CAACF,IAAI,CAAC,IAAI,CAAC;IAC3F,OAAO,IAAIG,UAAU,GAAG;EAC1B;AACF;AAACC,OAAA,CAAAhB,4BAAA,GAAAA,4BAAA","ignoreList":[]}

package/dist/schemas/class.d.ts

@@ -0,0 +1,59 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+import { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';
+export declare class ClassSchema extends SchemaNode {
+    readonly name: string;
+    readonly location: SchemaLocation;
+    readonly signature: string;
+    readonly typeParams?: string[] | undefined;
+    readonly extendsNodes?: ExpressionWithTypeArgumentsSchema[] | undefined;
+    readonly implementNodes?: ExpressionWithTypeArgumentsSchema[] | undefined;
+    readonly decorators?: SchemaNode[] | undefined;
+    readonly members: SchemaNode[];
+    readonly doc?: DocSchema;
+    constructor(name: string, members: SchemaNode[], location: SchemaLocation, signature: string, doc?: DocSchema, typeParams?: string[] | undefined, extendsNodes?: ExpressionWithTypeArgumentsSchema[] | undefined, implementNodes?: ExpressionWithTypeArgumentsSchema[] | undefined, decorators?: SchemaNode[] | undefined);
+    getNodes(): SchemaNode[];
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        name: string;
+        members: Record<string, any>[];
+        doc: {
+            __schema: string;
+            name: string | undefined;
+            location: SchemaLocation;
+            signature: string | undefined;
+            raw: string;
+            comment: string | undefined;
+            tags: {
+                __schema: string;
+                location: SchemaLocation;
+                name: string | undefined;
+                signature: string | undefined;
+                tagName: string;
+                comment: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        signature: string;
+        typeParams: string[] | undefined;
+        extendsNodes: {
+            name: string;
+            location: SchemaLocation;
+            typeArgs: Record<string, any>[];
+            expression: SchemaNode;
+        }[] | undefined;
+        implementNodes: {
+            name: string;
+            location: SchemaLocation;
+            typeArgs: Record<string, any>[];
+            expression: SchemaNode;
+        }[] | undefined;
+        decorators: Record<string, any>[] | undefined;
+    };
+    static fromObject(obj: Record<string, any>): ClassSchema;
+    static fromSchema(node: ClassSchema, memberTransformer?: (_node: SchemaNode) => SchemaNode): ClassSchema;
+}

package/dist/schemas/class.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ClassSchema = void 0;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _docs() {
+  const data = require("./docs");
+  _docs = function () {
+    return data;
+  };
+  return data;
+}
+function _expressionWithArguments() {
+  const data = require("./expression-with-arguments");
+  _expressionWithArguments = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ClassSchema extends _schemaNode().SchemaNode {
+  constructor(name, members, location, signature, doc, typeParams, extendsNodes, implementNodes, decorators) {
+    super();
+    this.name = name;
+    this.location = location;
+    this.signature = signature;
+    this.typeParams = typeParams;
+    this.extendsNodes = extendsNodes;
+    this.implementNodes = implementNodes;
+    this.decorators = decorators;
+    this.members = members;
+    this.doc = doc;
+  }
+  getNodes() {
+    return this.members;
+  }
+  toString(options) {
+    const boldUnderline = options?.color ? _chalk().default.bold.underline : str => str;
+    const membersStr = this.members.map(m => `* ${m.toString(options)}`).join('\n');
+    const decoratorsStr = this.decorators?.map(decorator => decorator.toString(options)).join('\n');
+    return `${this.decorators ? `${decoratorsStr}\n` : ''}${boldUnderline(this.name)}\n${membersStr}`;
+  }
+  toFullSignature(options) {
+    let result = '';
+    if (options?.showDocs && this.doc) {
+      result += `${this.doc.toFullSignature()}\n`;
+    }
+    const decoratorsStr = this.decorators?.map(decorator => decorator.toFullSignature(options)).join('\n');
+    if (decoratorsStr) {
+      result += `${decoratorsStr}\n`;
+    }
+    let classDeclaration = `class ${this.name}`;
+    if (this.typeParams && this.typeParams.length > 0) {
+      classDeclaration += `<${this.typeParams.join(', ')}>`;
+    }
+    if (this.extendsNodes && this.extendsNodes.length > 0) {
+      const extendsStr = this.extendsNodes.map(node => node.toFullSignature(options)).join(', ');
+      classDeclaration += ` extends ${extendsStr}`;
+    }
+    if (this.implementNodes && this.implementNodes.length > 0) {
+      const implementsStr = this.implementNodes.map(node => node.toFullSignature(options)).join(', ');
+      classDeclaration += ` implements ${implementsStr}`;
+    }
+    result += `${classDeclaration} {\n`;
+    const membersStr = this.members.map(member => {
+      const memberStr = member.toFullSignature(options);
+      return memberStr.split('\n').map(line => `  ${line}`).join('\n');
+    }).join('\n');
+    result += `${membersStr}\n`;
+    result += `}`;
+    return result;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      members: this.members.map(member => member.toObject()),
+      doc: this.doc?.toObject(),
+      signature: this.signature,
+      typeParams: this.typeParams,
+      extendsNodes: this.extendsNodes?.map(node => node.toObject()),
+      implementNodes: this.implementNodes?.map(node => node.toObject()),
+      decorators: this.decorators?.map(decorator => decorator.toObject())
+    };
+  }
+  static fromObject(obj) {
+    const name = obj.name;
+    const members = obj.members.map(member => _schemaRegistry().SchemaRegistry.fromObject(member));
+    const location = obj.location;
+    const signature = obj.signature;
+    const doc = obj.doc ? _docs().DocSchema.fromObject(obj.doc) : undefined;
+    const typeParams = obj.typeParams;
+    const extendsNodes = obj.extendsNodes?.map(node => _expressionWithArguments().ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const implementNodes = obj.implementNodes?.map(node => _expressionWithArguments().ExpressionWithTypeArgumentsSchema.fromObject(node));
+    const decorators = obj.decorators?.map(decorator => _schemaRegistry().SchemaRegistry.fromObject(decorator));
+    return new ClassSchema(name, members, location, signature, doc, typeParams, extendsNodes, implementNodes, decorators);
+  }
+  static fromSchema(node, memberTransformer = _node => _node) {
+    return new ClassSchema(node.name, node.members.map(memberTransformer), node.location, node.signature, node.doc, node.typeParams, node.extendsNodes, node.implementNodes, node.decorators);
+  }
+}
+exports.ClassSchema = ClassSchema;
+
+//# sourceMappingURL=class.js.map

package/dist/schemas/class.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_schemaNode","_docs","_expressionWithArguments","_schemaRegistry","e","__esModule","default","ClassSchema","SchemaNode","constructor","name","members","location","signature","doc","typeParams","extendsNodes","implementNodes","decorators","getNodes","toString","options","boldUnderline","color","chalk","bold","underline","str","membersStr","map","m","join","decoratorsStr","decorator","toFullSignature","result","showDocs","classDeclaration","length","extendsStr","node","implementsStr","member","memberStr","split","line","toObject","fromObject","obj","SchemaRegistry","DocSchema","undefined","ExpressionWithTypeArgumentsSchema","fromSchema","memberTransformer","_node","exports"],"sources":["class.ts"],"sourcesContent":["import chalk from 'chalk';\nimport { SchemaLocation, SchemaNode } from '../schema-node';\nimport { DocSchema } from './docs';\nimport { ExpressionWithTypeArgumentsSchema } from './expression-with-arguments';\nimport { SchemaRegistry } from '../schema-registry';\n\nexport class ClassSchema extends SchemaNode {\n  readonly members: SchemaNode[];\n  readonly doc?: DocSchema;\n\n  constructor(\n    readonly name: string,\n    members: SchemaNode[],\n    readonly location: SchemaLocation,\n    readonly signature: string,\n    doc?: DocSchema,\n    readonly typeParams?: string[],\n    readonly extendsNodes?: ExpressionWithTypeArgumentsSchema[],\n    readonly implementNodes?: ExpressionWithTypeArgumentsSchema[],\n    readonly decorators?: SchemaNode[]\n  ) {\n    super();\n    this.members = members;\n    this.doc = doc;\n  }\n\n  getNodes() {\n    return this.members;\n  }\n\n  toString(options?: { color?: boolean }): string {\n    const boldUnderline = options?.color ? chalk.bold.underline : (str: string) => str;\n    const membersStr = this.members.map((m) => `* ${m.toString(options)}`).join('\\n');\n    const decoratorsStr = this.decorators?.map((decorator) => decorator.toString(options)).join('\\n');\n    return `${this.decorators ? `${decoratorsStr}\\n` : ''}${boldUnderline(this.name)}\\n${membersStr}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    let result = '';\n\n    if (options?.showDocs && this.doc) {\n      result += `${this.doc.toFullSignature()}\\n`;\n    }\n\n    const decoratorsStr = this.decorators?.map((decorator) => decorator.toFullSignature(options)).join('\\n');\n    if (decoratorsStr) {\n      result += `${decoratorsStr}\\n`;\n    }\n\n    let classDeclaration = `class ${this.name}`;\n\n    if (this.typeParams && this.typeParams.length > 0) {\n      classDeclaration += `<${this.typeParams.join(', ')}>`;\n    }\n\n    if (this.extendsNodes && this.extendsNodes.length > 0) {\n      const extendsStr = this.extendsNodes.map((node) => node.toFullSignature(options)).join(', ');\n      classDeclaration += ` extends ${extendsStr}`;\n    }\n\n    if (this.implementNodes && this.implementNodes.length > 0) {\n      const implementsStr = this.implementNodes.map((node) => node.toFullSignature(options)).join(', ');\n      classDeclaration += ` implements ${implementsStr}`;\n    }\n\n    result += `${classDeclaration} {\\n`;\n\n    const membersStr = this.members\n      .map((member) => {\n        const memberStr = member.toFullSignature(options);\n        return memberStr\n          .split('\\n')\n          .map((line) => `  ${line}`)\n          .join('\\n');\n      })\n      .join('\\n');\n\n    result += `${membersStr}\\n`;\n\n    result += `}`;\n\n    return result;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      name: this.name,\n      members: this.members.map((member) => member.toObject()),\n      doc: this.doc?.toObject(),\n      signature: this.signature,\n      typeParams: this.typeParams,\n      extendsNodes: this.extendsNodes?.map((node) => node.toObject()),\n      implementNodes: this.implementNodes?.map((node) => node.toObject()),\n      decorators: this.decorators?.map((decorator) => decorator.toObject()),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): ClassSchema {\n    const name = obj.name;\n    const members = obj.members.map((member: any) => SchemaRegistry.fromObject(member));\n    const location = obj.location;\n    const signature = obj.signature;\n    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;\n    const typeParams = obj.typeParams;\n    const extendsNodes = obj.extendsNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));\n    const implementNodes = obj.implementNodes?.map((node: any) => ExpressionWithTypeArgumentsSchema.fromObject(node));\n    const decorators = obj.decorators?.map((decorator: any) => SchemaRegistry.fromObject(decorator));\n    return new ClassSchema(\n      name,\n      members,\n      location,\n      signature,\n      doc,\n      typeParams,\n      extendsNodes,\n      implementNodes,\n      decorators\n    );\n  }\n\n  static fromSchema(node: ClassSchema, memberTransformer: (_node: SchemaNode) => SchemaNode = (_node) => _node) {\n    return new ClassSchema(\n      node.name,\n      node.members.map(memberTransformer),\n      node.location,\n      node.signature,\n      node.doc,\n      node.typeParams,\n      node.extendsNodes,\n      node.implementNodes,\n      node.decorators\n    );\n  }\n}\n"],"mappings":"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","ignoreList":[]}

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

@@ -0,0 +1,25 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+/**
+ * e.g. `T extends U ? Y : N`
+ *
+ */
+export declare class ConditionalTypeSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly checkType: SchemaNode;
+    readonly extendsType: SchemaNode;
+    readonly trueType: SchemaNode;
+    readonly falseType: SchemaNode;
+    constructor(location: SchemaLocation, checkType: SchemaNode, extendsType: SchemaNode, trueType: SchemaNode, falseType: SchemaNode);
+    getNodes(): SchemaNode[];
+    toString(): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        checkType: Record<string, any>;
+        extendsType: Record<string, any>;
+        trueType: Record<string, any>;
+        falseType: Record<string, any>;
+    };
+    static fromObject(obj: Record<string, any>): ConditionalTypeSchema;
+}

package/dist/schemas/conditional-type.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ConditionalTypeSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+function _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * e.g. `T extends U ? Y : N`
+ *
+ */
+class ConditionalTypeSchema extends _schemaNode().SchemaNode {
+  constructor(location, checkType, extendsType, trueType, falseType) {
+    super();
+    this.location = location;
+    this.checkType = checkType;
+    this.extendsType = extendsType;
+    this.trueType = trueType;
+    this.falseType = falseType;
+  }
+  getNodes() {
+    return [this.checkType, this.extendsType, this.trueType, this.falseType];
+  }
+  toString() {
+    return `${this.checkType.toString()} extends ${this.extendsType.toString()} ? ${this.trueType.toString()} : ${this.falseType.toString()}`;
+  }
+  toFullSignature(options) {
+    const checkTypeStr = this.checkType.toFullSignature(options);
+    const extendsTypeStr = this.extendsType.toFullSignature(options);
+    const trueTypeStr = this.trueType.toFullSignature(options);
+    const falseTypeStr = this.falseType.toFullSignature(options);
+    return `${checkTypeStr} extends ${extendsTypeStr} ? ${trueTypeStr} : ${falseTypeStr}`;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      checkType: this.checkType.toObject(),
+      extendsType: this.extendsType.toObject(),
+      trueType: this.trueType.toObject(),
+      falseType: this.falseType.toObject()
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const checkType = _schemaRegistry().SchemaRegistry.fromObject(obj.checkType);
+    const extendsType = _schemaRegistry().SchemaRegistry.fromObject(obj.extendsType);
+    const trueType = _schemaRegistry().SchemaRegistry.fromObject(obj.trueType);
+    const falseType = _schemaRegistry().SchemaRegistry.fromObject(obj.falseType);
+    return new ConditionalTypeSchema(location, checkType, extendsType, trueType, falseType);
+  }
+}
+exports.ConditionalTypeSchema = ConditionalTypeSchema;
+
+//# sourceMappingURL=conditional-type.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","_schemaRegistry","ConditionalTypeSchema","SchemaNode","constructor","location","checkType","extendsType","trueType","falseType","getNodes","toString","toFullSignature","options","checkTypeStr","extendsTypeStr","trueTypeStr","falseTypeStr","toObject","fromObject","obj","SchemaRegistry","exports"],"sources":["conditional-type.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\nimport { SchemaRegistry } from '../schema-registry';\n\n/**\n * e.g. `T extends U ? Y : N`\n *\n */\nexport class ConditionalTypeSchema extends SchemaNode {\n  readonly checkType: SchemaNode;\n  readonly extendsType: SchemaNode;\n  readonly trueType: SchemaNode;\n  readonly falseType: SchemaNode;\n\n  constructor(\n    readonly location: SchemaLocation,\n    checkType: SchemaNode,\n    extendsType: SchemaNode,\n    trueType: SchemaNode,\n    falseType: SchemaNode\n  ) {\n    super();\n    this.checkType = checkType;\n    this.extendsType = extendsType;\n    this.trueType = trueType;\n    this.falseType = falseType;\n  }\n\n  getNodes() {\n    return [this.checkType, this.extendsType, this.trueType, this.falseType];\n  }\n\n  toString() {\n    return `${this.checkType.toString()} extends ${this.extendsType.toString()} ? ${this.trueType.toString()} : ${this.falseType.toString()}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    const checkTypeStr = this.checkType.toFullSignature(options);\n    const extendsTypeStr = this.extendsType.toFullSignature(options);\n    const trueTypeStr = this.trueType.toFullSignature(options);\n    const falseTypeStr = this.falseType.toFullSignature(options);\n\n    return `${checkTypeStr} extends ${extendsTypeStr} ? ${trueTypeStr} : ${falseTypeStr}`;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      checkType: this.checkType.toObject(),\n      extendsType: this.extendsType.toObject(),\n      trueType: this.trueType.toObject(),\n      falseType: this.falseType.toObject(),\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): ConditionalTypeSchema {\n    const location = obj.location;\n    const checkType = SchemaRegistry.fromObject(obj.checkType);\n    const extendsType = SchemaRegistry.fromObject(obj.extendsType);\n    const trueType = SchemaRegistry.fromObject(obj.trueType);\n    const falseType = SchemaRegistry.fromObject(obj.falseType);\n    return new ConditionalTypeSchema(location, checkType, extendsType, trueType, falseType);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/schemas/constructor.d.ts

@@ -0,0 +1,9 @@
+import { SchemaLocation } from '../schema-node';
+import { ParameterSchema } from './parameter';
+import { FunctionLikeSchema, Modifier } from './function-like';
+import { DocSchema } from './docs';
+import { ThisTypeSchema } from './this-type';
+export declare class ConstructorSchema extends FunctionLikeSchema {
+    constructor(location: SchemaLocation, params: ParameterSchema[], returnType: ThisTypeSchema, signature: string, modifiers?: Modifier[], doc?: DocSchema);
+    static fromObject(obj: Record<string, any>): ConstructorSchema;
+}