@flowgram-vue/json-schema 0.2.0

package/src/json-schema/type-definition/number.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { IJsonSchema, JsonSchemaTypeRegistryCreator } from '../types';
+import { createSvgVNode } from './svg-vnode';
+import { arrayNumberIcon } from './array-icons';
+
+export const numberRegistryCreator: JsonSchemaTypeRegistryCreator = () => ({
+  type: 'number',
+
+  label: 'Number',
+
+  extend: 'integer',
+
+  icon: createSvgVNode({
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+}, `<path d="M3.44151 5.3068C3.44151 3.83404 4.71542 2.64014 6.18818 2.64014C7.66094 2.64014 8.93484 3.83404 8.93484 5.3068V10.6135C8.93484 12.0862 7.66094 13.2801 6.18818 13.2801C4.71542 13.2801 3.44151 12.0862 3.44151 10.6135V5.3068ZM7.60151 5.3068C7.60151 4.57042 6.92456 3.97347 6.18818 3.97347C5.4518 3.97347 4.77484 4.57042 4.77484 5.3068V10.6135C4.77484 11.3498 5.4518 11.9468 6.18818 11.9468C6.92456 11.9468 7.60151 11.3498 7.60151 10.6135V5.3068Z" fill="currentColor" /> <path d="M12.9882 2.64014C11.5154 2.64014 10.2415 3.83404 10.2415 5.3068V10.6135C10.2415 12.0862 11.5154 13.2801 12.9882 13.2801C14.4609 13.2801 15.7348 12.0862 15.7348 10.6135V5.3068C15.7348 3.83404 14.4609 2.64014 12.9882 2.64014ZM14.4015 10.6135C14.4015 11.3498 13.7246 11.9468 12.9882 11.9468C12.2518 11.9468 11.5748 11.3498 11.5748 10.6135V5.3068C11.5748 4.57042 12.2518 3.97347 12.9882 3.97347C13.7246 3.97347 14.4015 4.57042 14.4015 5.3068V10.6135Z" fill="currentColor" /> <path d="M1.21484 13.2001C1.76713 13.2001 2.21484 12.7524 2.21484 12.2001C2.21484 11.6479 1.76713 11.2001 1.21484 11.2001C0.662559 11.2001 0.214844 11.6479 0.214844 12.2001C0.214844 12.7524 0.662559 13.2001 1.21484 13.2001Z" fill="currentColor" />`),
+
+  arrayIcon: arrayNumberIcon,
+
+  getValueText: (value?: unknown) => (value ? `${value}` : ''),
+
+  getDefaultSchema: (): IJsonSchema => ({ type: 'number' }),
+});

package/src/json-schema/type-definition/object.ts

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { IJsonSchema, JsonSchemaTypeRegistryCreator } from '../types';
+import { createSvgVNode } from './svg-vnode';
+import { arrayObjectIcon } from './array-icons';
+
+export const objectRegistryCreator: JsonSchemaTypeRegistryCreator = () => ({
+  type: 'object',
+  label: 'Object',
+
+  icon: createSvgVNode({
+  width: "16",
+  height: "16",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+}, `<path d="M5.33893 1.5835C5.66613 1.5835 5.93137 1.88142 5.93137 2.20862C5.93137 2.53582 5.66613 2.76838 5.33893 2.76838H4.9099C4.34717 2.76838 4.08062 3.07557 4.08062 3.71921V6.58633C4.08062 7.30996 3.80723 7.84734 3.26798 8.19105C3.11426 8.28902 3.10884 8.55273 3.26068 8.65359C3.80476 9.01503 4.08062 9.53994 4.08062 10.2434V13.1251C4.08062 13.7395 4.34717 14.0613 4.9099 14.0613H5.33893C5.66613 14.0613 5.93137 14.3435 5.93137 14.6707C5.93137 14.9979 5.66613 15.2462 5.33893 15.2462H4.64335C3.99177 15.2462 3.48828 15.0268 3.13287 14.6172C2.80708 14.2369 2.64419 13.7103 2.64419 13.0666V10.3165C2.64419 9.8923 2.55534 9.58511 2.37764 9.39494C2.26816 9.27135 1.80618 9.17938 1.38154 9.11602C1.02726 9.06315 0.759057 8.76744 0.765747 8.4093C0.772379 8.0543 1.03439 7.7566 1.38545 7.70346C1.80778 7.63952 2.26906 7.54968 2.37764 7.43477C2.55534 7.22997 2.64419 6.92278 2.64419 6.51319V3.77772C2.64419 3.11945 2.80708 2.59284 3.13287 2.21251C3.48828 1.78829 3.99177 1.5835 4.64335 1.5835H5.33893Z" fill="currentColor" /> <path d="M10.962 15.2463C10.6348 15.2463 10.3696 14.9483 10.3696 14.6211C10.3696 14.2939 10.6348 14.0614 10.962 14.0614H11.391C11.9538 14.0614 12.2203 13.7542 12.2203 13.1105V10.2434C12.2203 9.51979 12.4937 8.98241 13.033 8.6387C13.1867 8.54073 13.1921 8.27703 13.0403 8.17616C12.4962 7.81472 12.2203 7.28982 12.2203 6.58638V3.70463C12.2203 3.09024 11.9538 2.76842 11.391 2.76842L10.962 2.76842C10.6348 2.76842 10.3696 2.48627 10.3696 2.15907C10.3696 1.83188 10.6348 1.58354 10.962 1.58354L11.6576 1.58354C12.3092 1.58354 12.8127 1.80296 13.1681 2.21255C13.4939 2.59289 13.6568 3.1195 13.6568 3.76314V6.51324C13.6568 6.93745 13.7456 7.24464 13.9233 7.43481C14.03 7.5553 14.4328 7.64858 14.8186 7.71393C15.1718 7.77376 15.4401 8.06977 15.4334 8.42791C15.4268 8.78291 15.1646 9.08018 14.814 9.13633C14.4306 9.19774 14.0291 9.28303 13.9233 9.39499C13.7456 9.59978 13.6568 9.90697 13.6568 10.3166V13.052C13.6568 13.7103 13.4939 14.2369 13.1681 14.6172C12.8127 15.0415 12.3092 15.2463 11.6576 15.2463H10.962Z" fill="currentColor" />`),
+
+  arrayIcon: arrayObjectIcon,
+
+  getTypeSchemaProperties: (type: IJsonSchema): Record<string, IJsonSchema> =>
+    type.properties || {},
+
+  getPropertiesParent: (type) => type,
+
+  canAddField: () => true,
+
+  getDefaultSchema: (): IJsonSchema => ({
+    type: 'object',
+    required: [],
+    properties: {},
+  }),
+
+  getIJsonSchemaPropertiesParent: (type: IJsonSchema) => type,
+
+  getValueText: () => '',
+
+  getJsonPaths: () => ['properties'],
+
+  getDefaultValue: () => ({}),
+});

package/src/json-schema/type-definition/string.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { JsonSchemaTypeRegistryCreator } from '../types';
+import { createSvgVNode } from './svg-vnode';
+import { arrayStringIcon } from './array-icons';
+
+export const stringRegistryCreator: JsonSchemaTypeRegistryCreator = () => ({
+  type: 'string',
+
+  label: 'String',
+
+  icon: createSvgVNode({
+  width: "1em",
+  height: "1em",
+  viewBox: "0 0 16 16",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg"
+}, `<path d="M9.3342 3.33321C8.96601 3.33321 8.66753 3.63169 8.66753 3.99988C8.66753 4.36807 8.96601 4.66655 9.3342 4.66655H14.6675C15.0357 4.66655 15.3342 4.36807 15.3342 3.99988C15.3342 3.63169 15.0357 3.33321 14.6675 3.33321H9.3342Z" fill="currentColor" /> <path d="M10.0009 7.99988C10.0009 7.63169 10.2993 7.33321 10.6675 7.33321H14.6675C15.0357 7.33321 15.3342 7.63169 15.3342 7.99988C15.3342 8.36807 15.0357 8.66655 14.6675 8.66655H10.6675C10.2993 8.66655 10.0009 8.36807 10.0009 7.99988Z" fill="currentColor" /> <path d="M12.0009 11.3332C11.6327 11.3332 11.3342 11.6317 11.3342 11.9999C11.3342 12.3681 11.6327 12.6665 12.0009 12.6665H14.6675C15.0357 12.6665 15.3342 12.3681 15.3342 11.9999C15.3342 11.6317 15.0357 11.3332 14.6675 11.3332H12.0009Z" fill="currentColor" /> <path d="M9.86659 14.1482L8.23444 10.1844H3.18136C3.13868 10.1844 3.09685 10.1808 3.05616 10.1738L1.66589 14.1129C1.53049 14.4965 1.10971 14.6978 0.726058 14.5624C0.342408 14.427 0.141166 14.0062 0.276572 13.6225L4.37566 2.00848C4.71323 1.05202 6.05321 1.01763 6.4394 1.95552L11.2289 13.5872C11.3838 13.9634 11.2044 14.394 10.8282 14.5489C10.452 14.7038 10.0215 14.5244 9.86659 14.1482ZM5.44412 3.40791L3.57241 8.71109H7.62778L5.44412 3.40791Z" fill="currentColor" />`),
+
+  arrayIcon: arrayStringIcon,
+
+  getDefaultSchema: () => ({
+    type: 'string',
+  }),
+
+  getValueText: (value?: unknown) => (value ? `${value}` : ''),
+
+  getDefaultValue: () => '',
+});

package/src/json-schema/type-definition/svg-vnode.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { Comment, h, type VNode } from 'vue';
+
+export function createSvgVNode(
+  attrs: Record<string, string | number | boolean | undefined>,
+  innerHTML: string
+): VNode {
+  return h('svg', { ...attrs, innerHTML });
+}
+
+export function emptyVNode(): VNode {
+  return h(Comment);
+}

package/src/json-schema/type-definition/unknown.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { IJsonSchema, JsonSchemaTypeRegistryCreator } from '../types';
+import { createSvgVNode } from './svg-vnode';
+
+export const unknownRegistryCreator: JsonSchemaTypeRegistryCreator = () => ({
+  type: 'unknown',
+  label: 'Unknown',
+  parentType: [],
+
+  icon: createSvgVNode({
+  viewBox: "0 0 24 24",
+  fill: "none",
+  xmlns: "http://www.w3.org/2000/svg",
+  width: "1em",
+  height: "1em",
+  focusable: "false",
+  'aria-hidden': "true"
+}, `<path fill-rule="evenodd" clip-rule="evenodd" d="M4.22183 4.22182C6.21136 2.23232 8.96273 1 12 1C15.0373 1 17.7886 2.23231 19.7782 4.22182L19.0711 4.92893L19.7782 4.22183C21.7677 6.21136 23 8.96273 23 12C23 15.0373 21.7677 17.7886 19.7782 19.7782C17.7886 21.7677 15.0373 23 12 23C8.96273 23 6.21136 21.7677 4.22183 19.7782L4.92893 19.0711L4.22182 19.7782C2.23231 17.7886 1 15.0373 1 12C1 8.96273 2.23232 6.21136 4.22182 4.22183L4.22183 4.22182ZM12 3C9.51447 3 7.26584 4.00626 5.63603 5.63604C4.00625 7.26585 3 9.51447 3 12C3 14.4855 4.00627 16.7342 5.63604 18.3639C7.26584 19.9937 9.51447 21 12 21C14.4855 21 16.7342 19.9937 18.3639 18.3639C19.9937 16.7342 21 14.4855 21 12C21 9.51447 19.9937 7.26584 18.3639 5.63604C16.7342 4.00627 14.4855 3 12 3Z" fill="currentColor" ></path> <path fill-rule="evenodd" clip-rule="evenodd" d="M8 9.31245C8 7.10331 9.79086 5.31245 12 5.31245C14.2091 5.31245 16 7.10331 16 9.31245C16 11.1763 14.7252 12.7424 13 13.1864V14.3124C13 14.8647 12.5523 15.3124 12 15.3124C11.4477 15.3124 11 14.8647 11 14.3124V12.3124C11 11.7602 11.4477 11.3124 12 11.3124C13.1046 11.3124 14 10.417 14 9.31245C14 8.20788 13.1046 7.31245 12 7.31245C10.8954 7.31245 10 8.20788 10 9.31245C10 9.86473 9.55228 10.3124 9 10.3124C8.44772 10.3124 8 9.86473 8 9.31245Z" fill="currentColor" ></path> <path fill-rule="evenodd" clip-rule="evenodd" d="M12 18.8125C12.6904 18.8125 13.25 18.2528 13.25 17.5625C13.25 16.8721 12.6904 16.3125 12 16.3125C11.3097 16.3125 10.75 16.8721 10.75 17.5625C10.75 18.2528 11.3097 18.8125 12 18.8125Z" fill="currentColor" ></path>`),
+
+  getDefaultSchema: (): IJsonSchema => ({ type: 'unknown' } as unknown as IJsonSchema),
+
+  getDefaultValue: () => undefined,
+});

package/src/json-schema/types.ts

@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { type VNode } from 'vue';
+
+import { BaseTypeRegistry, TypeRegistryCreator } from '../base';
+import { type JsonSchemaTypeManager } from './json-schema-type-manager';
+
+export type JsonSchemaBasicType =
+  | 'boolean'
+  | 'string'
+  | 'integer'
+  | 'number'
+  | 'object'
+  | 'array'
+  | 'map';
+
+export interface IJsonSchema<T = string> {
+  type?: T;
+  /**
+   * The format of string
+   * https://json-schema.org/understanding-json-schema/reference/type#format
+   */
+  format?: string;
+  default?: any;
+  title?: string;
+  description?: string;
+  enum?: (string | number)[];
+  properties?: Record<string, IJsonSchema<T>>;
+  additionalProperties?: IJsonSchema<T>;
+  items?: IJsonSchema<T>;
+  required?: string[];
+  $ref?: string;
+  extra?: {
+    index?: number;
+    // Used in BaseType.isEqualWithJSONSchema, the type comparison will be weak
+    weak?: boolean;
+    // Set the render component
+    formComponent?: string;
+    [key: string]: any;
+  };
+}
+
+export type IBasicJsonSchema = IJsonSchema<JsonSchemaBasicType>;
+
+/**
+ * TypeRegistry based on IJsonSchema
+ */
+export interface JsonSchemaTypeRegistry<Schema extends Partial<IJsonSchema> = IJsonSchema>
+  extends BaseTypeRegistry {
+  /**
+   * The icon of this type
+   */
+  icon: VNode;
+  /**
+   * The icon displayed when this type is used as an array item
+   */
+  arrayIcon?: VNode;
+  /**
+   * The display text of this type, not including the icon
+   */
+  label: string;
+  /**
+   * Whether it is a container type
+   */
+  container: boolean;
+  /**
+   * Supported parent types. Some types can only appear as subtypes in type selection, but not as basic types.
+   */
+  parentType?: string[];
+
+  /*
+   * Get supported sub-types
+   */
+  getSupportedItemTypes?: (ctx: {
+    level: number;
+    parentTypes?: string[];
+  }) => Array<{ type: string; disabled?: string }>;
+
+  /**
+   * Get the display label
+   */
+  getDisplayLabel: (typeSchema: Schema) => VNode;
+
+  /**
+   * Get the display text
+   */
+  getDisplayText: (typeSchema: Schema) => string | undefined;
+
+  /**
+   * Get the sub-type
+   */
+  getItemType?: (typeSchema: Schema) => Schema | undefined;
+
+  /**
+   * Generate default Schema
+   */
+  getDefaultSchema: () => Schema;
+
+  /**
+   * onInit initialization logic, which is called at the appropriate time externally to register data into the type system
+   */
+  onInit?: () => void;
+
+  /**
+   * Whether to allow adding fields, such as object
+   */
+  canAddField: (typeSchema: Schema) => boolean;
+
+  /**
+   * Get the string value, for example
+   *  { type: "array", items: { type: "string" } }
+   *  The value is "array-string"
+   *
+   * The use case is that in some UI components, a string value needs to be generated
+   */
+  getStringValueByTypeSchema?: (optionValue: Schema) => string | undefined;
+
+  /**
+   * Restore the string value to typeSchema
+   * "array-string" is restored to
+   *  { type: "array", items: { type: "string" } }
+   */
+  getTypeSchemaByStringValue?: (type: string) => Schema;
+
+  /**
+   * Get the display icon, and the composite icon of the array is also processed
+   */
+  getDisplayIcon: (typeSchema: Schema) => VNode;
+
+  /**
+   * Get sub-properties
+   */
+  getTypeSchemaProperties: (typeSchema: Schema) => Record<string, Schema> | undefined;
+
+  /**
+   * Get the default value
+   */
+  getDefaultValue: () => unknown;
+
+  /**
+   * Get the display text based on the value
+   */
+  getValueText: (value?: unknown) => string;
+  /**
+   * Get the json path of a certain type in the flow schema
+   * For example
+   * { type: "object", properties: { name: { type: "string" } } }
+   * -> ['properties', 'name']
+   * { type: "array", items: { type: "string" } }
+   * ->['items']
+   */
+  getJsonPaths: (typeSchema: Schema) => string[];
+
+  /**
+   * Get the parent node of the sub-field
+   * object is itself
+   * array<object> is items
+   * map<object> is additionalProperties
+   */
+  getPropertiesParent: (typeSchema: Schema) => Schema | undefined;
+  /**
+   * The complexText of a custom type
+   * For example, Array<string>, can be modified
+   */
+  customComplexText?: (typeSchema: Schema) => string;
+}
+
+export type JsonSchemaTypeRegistryCreator<
+  Schema extends Partial<IJsonSchema> = IJsonSchema,
+  Registry extends JsonSchemaTypeRegistry<Schema> = JsonSchemaTypeRegistry<Schema>,
+  Manager extends JsonSchemaTypeManager<Schema, Registry> = JsonSchemaTypeManager<Schema, Registry>
+> = TypeRegistryCreator<Schema, Registry, Manager>;

package/src/json-schema/utils.ts

@@ -0,0 +1,212 @@
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+import { get } from 'lodash-es';
+import {
+  ASTFactory,
+  ASTKind,
+  ASTMatch,
+  ASTNode,
+  ASTNodeJSON,
+  BaseType,
+} from '@flowgram-vue/variable-core';
+
+import { IJsonSchema } from './types';
+
+export namespace JsonSchemaUtils {
+  /**
+   * Converts a JSON schema to an Abstract Syntax Tree (AST) representation.
+   * This function recursively processes the JSON schema and creates corresponding AST nodes.
+   *
+   * For more information on JSON Schema, refer to the official documentation:
+   * https://json-schema.org/
+   *
+   * @param jsonSchema - The JSON schema to convert.
+   * @returns An AST node representing the JSON schema, or undefined if the schema type is not recognized.
+   */
+  export function schemaToAST(jsonSchema: IJsonSchema): ASTNodeJSON | undefined {
+    const { type, extra, required } = jsonSchema || {};
+    const { weak = false } = extra || {};
+
+    if (!type) {
+      return undefined;
+    }
+
+    switch (type) {
+      case 'object':
+        if (weak) {
+          return { kind: ASTKind.Object, weak: true };
+        }
+        return ASTFactory.createObject({
+          properties: Object.entries(jsonSchema.properties || {})
+            /**
+             * Sorts the properties of a JSON schema based on the 'extra.index' field.
+             * If the 'extra.index' field is not present, the property will be treated as having an index of 0.
+             */
+            .sort((a, b) => (get(a?.[1], 'extra.index') || 0) - (get(b?.[1], 'extra.index') || 0))
+            .map(([key, _property]) => ({
+              key,
+              type: schemaToAST(_property),
+              meta: {
+                title: _property.title,
+                description: _property.description,
+                required: !!required?.includes(key),
+                default: _property.default,
+              },
+            })),
+        });
+      case 'array':
+        if (weak) {
+          return { kind: ASTKind.Array, weak: true };
+        }
+        return ASTFactory.createArray({
+          items: schemaToAST(jsonSchema.items!),
+        });
+      case 'map':
+        if (weak) {
+          return { kind: ASTKind.Map, weak: true };
+        }
+        return ASTFactory.createMap({
+          valueType: schemaToAST(jsonSchema.additionalProperties!),
+        });
+      case 'string':
+        return ASTFactory.createString({ format: jsonSchema.format });
+      case 'number':
+        return ASTFactory.createNumber();
+      case 'boolean':
+        return ASTFactory.createBoolean();
+      case 'integer':
+        return ASTFactory.createInteger();
+
+      default:
+        // If the type is not recognized, return CustomType
+        return ASTFactory.createCustomType({ typeName: type });
+    }
+  }
+
+  /**
+   * Convert AST To JSON Schema
+   * @param typeAST
+   * @returns
+   */
+  export function astToSchema(
+    typeAST?: ASTNode,
+    options?: {
+      drilldown?: boolean;
+      drilldownObject?: boolean;
+      drilldownMap?: boolean;
+      drilldownArray?: boolean;
+    }
+  ): IJsonSchema | undefined {
+    const {
+      drilldown = true,
+      drilldownMap = drilldown,
+      drilldownObject = drilldown,
+      drilldownArray = drilldown,
+    } = options || {};
+
+    if (!typeAST) {
+      return undefined;
+    }
+
+    if (ASTMatch.isString(typeAST)) {
+      return {
+        type: 'string',
+        format: typeAST.format,
+      };
+    }
+
+    if (ASTMatch.isBoolean(typeAST)) {
+      return {
+        type: 'boolean',
+      };
+    }
+
+    if (ASTMatch.isNumber(typeAST)) {
+      return {
+        type: 'number',
+      };
+    }
+
+    if (ASTMatch.isInteger(typeAST)) {
+      return {
+        type: 'integer',
+      };
+    }
+
+    if (ASTMatch.isObject(typeAST)) {
+      return {
+        type: 'object',
+        required: typeAST.properties
+          .filter((property) => property.meta?.required)
+          .map((property) => property.key),
+        properties: drilldownObject
+          ? Object.fromEntries(
+              typeAST.properties.map((property) => {
+                const schema = astToSchema(property.type);
+
+                if (property.meta?.title && schema) {
+                  schema.title = property.meta.title;
+                }
+                if (property.meta?.description && schema) {
+                  schema.description = property.meta.description;
+                }
+                if (property.meta?.default && schema) {
+                  schema.default = property.meta.default;
+                }
+
+                return [property.key, schema!];
+              })
+            )
+          : {},
+      };
+    }
+
+    if (ASTMatch.isArray(typeAST)) {
+      return {
+        type: 'array',
+        items: drilldownArray ? astToSchema(typeAST.items) : undefined,
+      };
+    }
+
+    if (ASTMatch.isMap(typeAST)) {
+      return {
+        type: 'map',
+        items: drilldownMap ? astToSchema(typeAST.valueType) : undefined,
+      };
+    }
+
+    if (ASTMatch.isCustomType(typeAST)) {
+      return {
+        type: typeAST.typeName,
+      };
+    }
+
+    console.warn('JsonSchemaUtils.astToSchema: AST must extends BaseType', typeAST);
+
+    return undefined;
+  }
+
+  /**
+   * Check if the AST type is match the JSON Schema
+   * @param typeAST
+   * @param schema
+   * @returns
+   */
+  export function isASTMatchSchema(
+    typeAST: BaseType,
+    schema: IJsonSchema | IJsonSchema[]
+  ): boolean {
+    if (Array.isArray(schema)) {
+      return typeAST.isTypeEqual(
+        ASTFactory.createUnion({
+          types: schema.map((_schema) => schemaToAST(_schema)!).filter(Boolean),
+        })
+      );
+    }
+
+    return typeAST.isTypeEqual(schemaToAST(schema));
+  }
+}