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

package/dist/schemas/unknown-schema.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnknownSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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.
+ */
+class UnknownSchema extends _schemaNode().SchemaNode {
+  constructor(location, name, schemaObj) {
+    super();
+    this.location = location;
+    this.name = name;
+    this.schemaObj = schemaObj;
+  }
+  toString() {
+    return `<<unknown schema ${this.name}>>`;
+  }
+  toFullSignature() {
+    return this.toString();
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      schemaObj: this.schemaObj
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    const schemaObj = obj.schemaObj;
+    return new UnknownSchema(location, name, schemaObj);
+  }
+}
+exports.UnknownSchema = UnknownSchema;
+
+//# sourceMappingURL=unknown-schema.js.map

package/dist/schemas/unknown-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","UnknownSchema","SchemaNode","constructor","location","name","schemaObj","toString","toFullSignature","toObject","fromObject","obj","exports"],"sources":["unknown-schema.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\n\n/**\n * needed for better backward and forward compatibility.\n * in case a previous version of the semantic-schema had a schema class that doesn't exist anymore, then it'll be\n * wrapped in this class.\n */\nexport class UnknownSchema extends SchemaNode {\n  constructor(\n    readonly location: SchemaLocation,\n    readonly name: string,\n    readonly schemaObj: Record<string, any>\n  ) {\n    super();\n  }\n\n  toString() {\n    return `<<unknown schema ${this.name}>>`;\n  }\n\n  toFullSignature(): string {\n    return this.toString();\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      schemaObj: this.schemaObj,\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): UnknownSchema {\n    const location = obj.location;\n    const name = obj.name;\n    const schemaObj = obj.schemaObj;\n    return new UnknownSchema(location, name, schemaObj);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACA;AACA;AACO,MAAME,aAAa,SAASC,wBAAU,CAAC;EAC5CC,WAAWA,CACAC,QAAwB,EACxBC,IAAY,EACZC,SAA8B,EACvC;IACA,KAAK,CAAC,CAAC;IAAC,KAJCF,QAAwB,GAAxBA,QAAwB;IAAA,KACxBC,IAAY,GAAZA,IAAY;IAAA,KACZC,SAA8B,GAA9BA,SAA8B;EAGzC;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,oBAAoB,IAAI,CAACF,IAAI,IAAI;EAC1C;EAEAG,eAAeA,CAAA,EAAW;IACxB,OAAO,IAAI,CAACD,QAAQ,CAAC,CAAC;EACxB;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO;MACL,GAAG,KAAK,CAACA,QAAQ,CAAC,CAAC;MACnBH,SAAS,EAAE,IAAI,CAACA;IAClB,CAAC;EACH;EAEA,OAAOI,UAAUA,CAACC,GAAwB,EAAiB;IACzD,MAAMP,QAAQ,GAAGO,GAAG,CAACP,QAAQ;IAC7B,MAAMC,IAAI,GAAGM,GAAG,CAACN,IAAI;IACrB,MAAMC,SAAS,GAAGK,GAAG,CAACL,SAAS;IAC/B,OAAO,IAAIL,aAAa,CAACG,QAAQ,EAAEC,IAAI,EAAEC,SAAS,CAAC;EACrD;AACF;AAACM,OAAA,CAAAX,aAAA,GAAAA,aAAA","ignoreList":[]}

package/dist/schemas/unresolved-schema.d.ts

@@ -0,0 +1,14 @@
+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 declare class UnresolvedSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly name: string;
+    constructor(location: SchemaLocation, name: string);
+    toString(): string;
+    toFullSignature(): string;
+    toObject(): Record<string, any>;
+    static fromObject(obj: Record<string, any>): UnresolvedSchema;
+}

package/dist/schemas/unresolved-schema.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnresolvedSchema = void 0;
+function _schemaNode() {
+  const data = require("../schema-node");
+  _schemaNode = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * needed for cases when the exported entity could not be resolved.
+ * e.g. exporting mdx variables in the main index.ts file.
+ */
+class UnresolvedSchema extends _schemaNode().SchemaNode {
+  constructor(location, name) {
+    super();
+    this.location = location;
+    this.name = name;
+  }
+  toString() {
+    return this.name;
+  }
+  toFullSignature() {
+    return this.toString();
+  }
+  toObject() {
+    return super.toObject();
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    return new UnresolvedSchema(location, name);
+  }
+}
+exports.UnresolvedSchema = UnresolvedSchema;
+
+//# sourceMappingURL=unresolved-schema.js.map

package/dist/schemas/unresolved-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_schemaNode","data","require","UnresolvedSchema","SchemaNode","constructor","location","name","toString","toFullSignature","toObject","fromObject","obj","exports"],"sources":["unresolved-schema.ts"],"sourcesContent":["import { SchemaLocation, SchemaNode } from '../schema-node';\n\n/**\n * needed for cases when the exported entity could not be resolved.\n * e.g. exporting mdx variables in the main index.ts file.\n */\nexport class UnresolvedSchema extends SchemaNode {\n  constructor(\n    readonly location: SchemaLocation,\n    readonly name: string\n  ) {\n    super();\n  }\n\n  toString() {\n    return this.name;\n  }\n\n  toFullSignature(): string {\n    return this.toString();\n  }\n\n  toObject() {\n    return super.toObject();\n  }\n\n  static fromObject(obj: Record<string, any>): UnresolvedSchema {\n    const location = obj.location;\n    const name = obj.name;\n    return new UnresolvedSchema(location, name);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,YAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,WAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA;AACA;AACA;AACA;AACO,MAAME,gBAAgB,SAASC,wBAAU,CAAC;EAC/CC,WAAWA,CACAC,QAAwB,EACxBC,IAAY,EACrB;IACA,KAAK,CAAC,CAAC;IAAC,KAHCD,QAAwB,GAAxBA,QAAwB;IAAA,KACxBC,IAAY,GAAZA,IAAY;EAGvB;EAEAC,QAAQA,CAAA,EAAG;IACT,OAAO,IAAI,CAACD,IAAI;EAClB;EAEAE,eAAeA,CAAA,EAAW;IACxB,OAAO,IAAI,CAACD,QAAQ,CAAC,CAAC;EACxB;EAEAE,QAAQA,CAAA,EAAG;IACT,OAAO,KAAK,CAACA,QAAQ,CAAC,CAAC;EACzB;EAEA,OAAOC,UAAUA,CAACC,GAAwB,EAAoB;IAC5D,MAAMN,QAAQ,GAAGM,GAAG,CAACN,QAAQ;IAC7B,MAAMC,IAAI,GAAGK,GAAG,CAACL,IAAI;IACrB,OAAO,IAAIJ,gBAAgB,CAACG,QAAQ,EAAEC,IAAI,CAAC;EAC7C;AACF;AAACM,OAAA,CAAAV,gBAAA,GAAAA,gBAAA","ignoreList":[]}

package/dist/schemas/variable-like.d.ts

@@ -0,0 +1,47 @@
+import { SchemaLocation, SchemaNode } from '../schema-node';
+import { DocSchema } from './docs';
+/**
+ * can be also a property or property-signature
+ */
+export declare class VariableLikeSchema extends SchemaNode {
+    readonly location: SchemaLocation;
+    readonly name: string;
+    readonly signature: string;
+    readonly isOptional: boolean;
+    readonly defaultValue?: string | undefined;
+    type: SchemaNode;
+    readonly doc?: DocSchema;
+    readonly displaySchemaName = "Variables";
+    constructor(location: SchemaLocation, name: string, signature: string, type: SchemaNode, isOptional: boolean, doc?: DocSchema, defaultValue?: string | undefined);
+    getNodes(): SchemaNode[];
+    toString(options?: {
+        color?: boolean;
+    }): string;
+    toFullSignature(options?: {
+        showDocs?: boolean;
+    }): string;
+    toObject(): {
+        name: string;
+        signature: string;
+        type: Record<string, any>;
+        isOptional: boolean;
+        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;
+        defaultValue: string | undefined;
+    };
+    static fromObject(obj: Record<string, any>): VariableLikeSchema;
+}

package/dist/schemas/variable-like.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VariableLikeSchema = 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 _schemaRegistry() {
+  const data = require("../schema-registry");
+  _schemaRegistry = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * can be also a property or property-signature
+ */
+class VariableLikeSchema extends _schemaNode().SchemaNode {
+  displaySchemaName = 'Variables';
+  constructor(location, name, signature, type, isOptional, doc, defaultValue) {
+    super();
+    this.location = location;
+    this.name = name;
+    this.signature = signature;
+    this.isOptional = isOptional;
+    this.defaultValue = defaultValue;
+    this.type = type;
+    this.doc = doc;
+  }
+  getNodes() {
+    return [this.type];
+  }
+  toString(options) {
+    const bold = options?.color ? _chalk().default.bold : str => str;
+    return `${bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString(options)}`;
+  }
+  toFullSignature(options) {
+    const namePart = `${this.name}${this.isOptional ? '?' : ''}`;
+    const typeSignature = this.type.toFullSignature(options);
+    let signature = `${namePart}: ${typeSignature}`;
+    if (this.defaultValue !== undefined) {
+      signature += ` = ${this.defaultValue}`;
+    }
+    if (options?.showDocs && this.doc) {
+      const docString = this.doc.toFullSignature();
+      signature = `${docString}\n${signature}`;
+    }
+    return signature;
+  }
+  toObject() {
+    return {
+      ...super.toObject(),
+      name: this.name,
+      signature: this.signature,
+      type: this.type.toObject(),
+      isOptional: this.isOptional,
+      doc: this.doc?.toObject(),
+      defaultValue: this.defaultValue
+    };
+  }
+  static fromObject(obj) {
+    const location = obj.location;
+    const name = obj.name;
+    const signature = obj.signature;
+    const type = _schemaRegistry().SchemaRegistry.fromObject(obj.type);
+    const isOptional = obj.isOptional;
+    const doc = obj.doc ? _docs().DocSchema.fromObject(obj.doc) : undefined;
+    const defaultValue = obj.defaultValue;
+    return new VariableLikeSchema(location, name, signature, type, isOptional, doc, defaultValue);
+  }
+}
+exports.VariableLikeSchema = VariableLikeSchema;
+
+//# sourceMappingURL=variable-like.js.map

package/dist/schemas/variable-like.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_schemaNode","_docs","_schemaRegistry","e","__esModule","default","VariableLikeSchema","SchemaNode","displaySchemaName","constructor","location","name","signature","type","isOptional","doc","defaultValue","getNodes","toString","options","bold","color","chalk","str","toFullSignature","namePart","typeSignature","undefined","showDocs","docString","toObject","fromObject","obj","SchemaRegistry","DocSchema","exports"],"sources":["variable-like.ts"],"sourcesContent":["import chalk from 'chalk';\nimport { SchemaLocation, SchemaNode } from '../schema-node';\nimport { DocSchema } from './docs';\nimport { SchemaRegistry } from '../schema-registry';\n\n/**\n * can be also a property or property-signature\n */\nexport class VariableLikeSchema extends SchemaNode {\n  type: SchemaNode;\n  readonly doc?: DocSchema;\n  readonly displaySchemaName = 'Variables';\n\n  constructor(\n    readonly location: SchemaLocation,\n    readonly name: string,\n    readonly signature: string,\n    type: SchemaNode,\n    readonly isOptional: boolean,\n    doc?: DocSchema,\n    readonly defaultValue?: string\n  ) {\n    super();\n    this.type = type;\n    this.doc = doc;\n  }\n\n  getNodes() {\n    return [this.type];\n  }\n\n  toString(options?: { color?: boolean }) {\n    const bold = options?.color ? chalk.bold : (str: string) => str;\n    return `${bold(this.name)}${this.isOptional ? '?' : ''}: ${this.type.toString(options)}`;\n  }\n\n  toFullSignature(options?: { showDocs?: boolean }): string {\n    const namePart = `${this.name}${this.isOptional ? '?' : ''}`;\n    const typeSignature = this.type.toFullSignature(options);\n    let signature = `${namePart}: ${typeSignature}`;\n\n    if (this.defaultValue !== undefined) {\n      signature += ` = ${this.defaultValue}`;\n    }\n\n    if (options?.showDocs && this.doc) {\n      const docString = this.doc.toFullSignature();\n      signature = `${docString}\\n${signature}`;\n    }\n\n    return signature;\n  }\n\n  toObject() {\n    return {\n      ...super.toObject(),\n      name: this.name,\n      signature: this.signature,\n      type: this.type.toObject(),\n      isOptional: this.isOptional,\n      doc: this.doc?.toObject(),\n      defaultValue: this.defaultValue,\n    };\n  }\n\n  static fromObject(obj: Record<string, any>): VariableLikeSchema {\n    const location = obj.location;\n    const name = obj.name;\n    const signature = obj.signature;\n    const type = SchemaRegistry.fromObject(obj.type);\n    const isOptional = obj.isOptional;\n    const doc = obj.doc ? DocSchema.fromObject(obj.doc) : undefined;\n    const defaultValue = obj.defaultValue;\n    return new VariableLikeSchema(location, name, signature, type, isOptional, doc, defaultValue);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/semantic-schema.docs.md

@@ -0,0 +1,6 @@
+---
+description: Describes the API schema for a component.
+labels: ['api', 'schema', 'semantic']
+---
+
+...

package/dist/type.d.ts

@@ -0,0 +1 @@
+export type TypeRef = {};

package/dist/type.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=type.js.map

package/dist/type.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["type.ts"],"sourcesContent":["export type TypeRef = {};\n"],"mappings":"","ignoreList":[]}

package/dist/unknown-schema-factory.d.ts

@@ -0,0 +1,4 @@
+import { SchemaLocation } from './schema-node';
+export declare class UnknownSchemaFactory {
+    static create(location: SchemaLocation, name: string, schemaObj: Record<string, any>): any;
+}

package/dist/unknown-schema-factory.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UnknownSchemaFactory = void 0;
+class UnknownSchemaFactory {
+  static create(location, name, schemaObj) {
+    // dynamic require() to import UnknownSchema at runtime when it's needed, which breaks the circular dependency.
+    // eslint-disable-next-line global-require
+    const {
+      UnknownSchema
+    } = require('./schemas/unknown-schema');
+    return new UnknownSchema(location, name, schemaObj);
+  }
+}
+exports.UnknownSchemaFactory = UnknownSchemaFactory;
+
+//# sourceMappingURL=unknown-schema-factory.js.map

package/dist/unknown-schema-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["UnknownSchemaFactory","create","location","name","schemaObj","UnknownSchema","require","exports"],"sources":["unknown-schema-factory.ts"],"sourcesContent":["import { SchemaLocation } from './schema-node';\n\nexport class UnknownSchemaFactory {\n  static create(location: SchemaLocation, name: string, schemaObj: Record<string, any>): any {\n    // dynamic require() to import UnknownSchema at runtime when it's needed, which breaks the circular dependency.\n    // eslint-disable-next-line global-require\n    const { UnknownSchema } = require('./schemas/unknown-schema');\n    return new UnknownSchema(location, name, schemaObj);\n  }\n}\n"],"mappings":";;;;;;AAEO,MAAMA,oBAAoB,CAAC;EAChC,OAAOC,MAAMA,CAACC,QAAwB,EAAEC,IAAY,EAAEC,SAA8B,EAAO;IACzF;IACA;IACA,MAAM;MAAEC;IAAc,CAAC,GAAGC,OAAO,CAAC,0BAA0B,CAAC;IAC7D,OAAO,IAAID,aAAa,CAACH,QAAQ,EAAEC,IAAI,EAAEC,SAAS,CAAC;EACrD;AACF;AAACG,OAAA,CAAAP,oBAAA,GAAAA,oBAAA","ignoreList":[]}

package/export.ts

@@ -0,0 +1,31 @@
+type Primitive = string | number | boolean | null | undefined;
+export type StaticProperties = Map<string, Primitive>;
+
+/**
+ * @todo: this was implemented before all other schemas and is used only for composition.
+ * it needs to be align with other schemas.
+ */
+export class Export {
+  constructor(
+    /**
+     * named export identifier of the module export.
+     */
+    readonly identifier: string,
+
+    /**
+     * static properties attached to this export
+     * @example
+     * export hello = () => {};
+     * hello.value = "text"; // <-- staticProperty
+     * hello.count = 3; // <-- static property
+     */
+    readonly staticProperties?: StaticProperties
+  ) {}
+
+  toObject() {
+    return {
+      constructorName: this.constructor.name,
+      identifier: this.identifier,
+    };
+  }
+}

package/index.ts

@@ -0,0 +1,13 @@
+import * as Schemas from './schemas';
+
+export { SchemaNode, ISchemaNode } from './schema-node';
+export { APISchema } from './api-schema';
+export { Export, StaticProperties } from './export';
+export type { SchemaLocation as Location } from './schema-node';
+export { TagName } from './schemas/docs/tag';
+export { SchemaRegistry } from './schema-registry';
+export { SchemaNodeConstructor } from './schema-node-constructor';
+export { Modifier } from './schemas/function-like';
+export { Schemas };
+
+export * from './schemas';

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@teambit/semantics.entities.semantic-schema",
+  "version": "0.0.0-e4ef0e951da794f03096a5cc407420f4cde8b878",
+  "homepage": "https://bit.cloud/teambit/semantics/entities/semantic-schema",
+  "main": "dist/index.js",
+  "componentId": {
+    "scope": "teambit.semantics",
+    "name": "entities/semantic-schema",
+    "version": "e4ef0e951da794f03096a5cc407420f4cde8b878"
+  },
+  "dependencies": {
+    "chalk": "4.1.2",
+    "lodash": "4.17.21",
+    "pluralize": "8.0.0",
+    "@teambit/component-id": "1.2.4"
+  },
+  "devDependencies": {
+    "@types/lodash": "4.14.165",
+    "@types/pluralize": "0.0.29",
+    "@types/mocha": "9.1.0",
+    "chai": "4.3.0",
+    "@teambit/node.envs.node-babel-mocha": "0.1.18"
+  },
+  "peerDependencies": {},
+  "license": "Apache-2.0",
+  "optionalDependencies": {},
+  "peerDependenciesMeta": {},
+  "private": false,
+  "engines": {
+    "node": ">=12.22.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/teambit/bit"
+  },
+  "keywords": [
+    "bit",
+    "components",
+    "collaboration",
+    "web",
+    "react",
+    "react-components",
+    "angular",
+    "angular-components"
+  ]
+}

package/schema-node-constructor.ts

@@ -0,0 +1,8 @@
+import { SchemaNode } from './schema-node';
+
+export interface SchemaNodeConstructor {
+  new (...args: any[]): SchemaNode;
+  readonly prototype: SchemaNode;
+  name: string;
+  fromObject(obj: Record<string, any>): SchemaNode;
+}

package/schema-node.ts

@@ -0,0 +1,96 @@
+import { pickBy } from 'lodash';
+import pluralize from 'pluralize';
+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 abstract class SchemaNode implements ISchemaNode {
+  readonly __schema = this.constructor.name;
+  readonly displaySchemaName = pluralize(
+    this.constructor.name
+      .replace(/Schema$/, '')
+      .replace(/([A-Z])/g, ' $1')
+      .trim()
+  );
+
+  abstract readonly location: SchemaLocation;
+  readonly doc?: DocSchema;
+  readonly signature?: string;
+  readonly name?: string;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static fromObject(obj: Record<string, any>): SchemaNode {
+    throw new Error(`Method 'fromObject' not implemented in subclass.`);
+  }
+
+  toObject(): Record<string, any> {
+    return pickBy(
+      {
+        __schema: this.__schema,
+        location: this.location,
+        doc: this.doc ? this.doc.toObject() : undefined,
+        signature: this.signature,
+        name: this.name,
+      },
+      (v) => v !== undefined
+    );
+  }
+
+  abstract toString(options?: { color?: boolean }): string;
+  abstract toFullSignature(options?: { showDocs?: boolean }): string;
+
+  getNodes(): SchemaNode[] {
+    return [this];
+  }
+
+  getAllNodesRecursively(visitedNodes = new Set<SchemaNode>()): SchemaNode[] {
+    if (visitedNodes.has(this)) {
+      return [];
+    }
+
+    visitedNodes.add(this);
+
+    const nodes = this.getNodes();
+    return [this, ...nodes.flatMap((node) => node.getAllNodesRecursively(visitedNodes))];
+  }
+
+  findNode(predicate: (node: SchemaNode) => boolean, visitedNodes = new Set<SchemaNode>()): SchemaNode | undefined {
+    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;
+  }
+}
+
+export type SchemaLocation = {
+  /**
+   * file-path relative to the component root-dir. normalized to Linux.
+   */
+  filePath: string;
+  line: number;
+  character: number;
+};

package/schema-registry.ts

@@ -0,0 +1,53 @@
+import { SchemaNodeConstructor } from './schema-node-constructor';
+import { UnknownSchemaFactory } from './unknown-schema-factory';
+
+type GetSchemaFunc = () => SchemaNodeConstructor[];
+
+export class SchemaRegistry {
+  private static instance = new SchemaRegistry();
+  private _schemas: Record<string, SchemaNodeConstructor>;
+  private _getSchemas: GetSchemaFunc[] = [];
+
+  private constructor() {
+    this._schemas = {};
+  }
+
+  static registerGetSchemas(getSchemas: GetSchemaFunc) {
+    this.instance._getSchemas.push(getSchemas);
+  }
+
+  /**
+   * @deprecated use registerGetSchemas instead
+   * registerGetSchemas is better for performance as it lazy-loads the schemas.
+   */
+  static register(schema: SchemaNodeConstructor) {
+    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: Record<string, any>) {
+    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.create(obj.location || { path: '', line: 0, character: 0 }, obj.__schema, obj);
+    }
+    return SchemaClass.fromObject(obj);
+  }
+}

package/schemas/array-literal-expression.ts

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