@flowgram.ai/json-schema 0.3.0

package/dist/index.d.ts

@@ -0,0 +1,271 @@
+import * as _flowgram_ai_utils from '@flowgram.ai/utils';
+import { Emitter } from '@flowgram.ai/utils';
+import React$1 from 'react';
+import { ContainerModule } from 'inversify';
+import { ASTNodeJSON, ASTNode, BaseType } from '@flowgram.ai/variable-core';
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * Base information for TypeRegistry
+ */
+interface BaseTypeRegistry {
+    /**
+     * type reference
+     */
+    type: string;
+    /**
+     * The inherited type. If there is an inheritance, the definition of this type will use the inherited type definition,
+     * and the new definition will override the inherited definition.
+     */
+    extend?: string;
+}
+/**
+ * TypeRegistryCreator
+ */
+type TypeRegistryCreator<Schema, Registry extends BaseTypeRegistry, Manager extends BaseTypeManager<Schema, Registry, Manager>> = (ctx: {
+    typeManager: Manager;
+}) => Partial<Registry>;
+
+declare abstract class BaseTypeManager<Schema, Registry extends BaseTypeRegistry, Manager extends BaseTypeManager<Schema, Registry, Manager>> {
+    protected typeRegistryMap: Map<string, Registry>;
+    protected onTypeRegistryChangeEmitter: Emitter<Registry[]>;
+    onTypeRegistryChange: _flowgram_ai_utils.Event<Registry[]>;
+    /**
+     * 获取 typeSchema 对应的 type
+     * 不能直接访问 type 的原因的是
+     * Schema 中 type 可能为空，需要获取 $ref 中的 type
+     */
+    protected abstract getTypeNameFromSchema(typeSchema: Schema): string;
+    getTypeByName(typeName: string): Registry | undefined;
+    getTypeBySchema(type: Schema): Registry | undefined;
+    getDefaultTypeRegistry(): Registry | undefined;
+    /**
+     * 注册 TypeRegistry
+     */
+    register(originRegistry: Partial<Registry> | TypeRegistryCreator<Schema, Registry, Manager>): void;
+    triggerChanges(): void;
+    /**
+     * 获取全量的 TypeRegistries
+     */
+    getAllTypeRegistries(): Registry[];
+    unregister(type: string): void;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare class JsonSchemaTypeManager<Schema extends Partial<IJsonSchema> = IJsonSchema, Registry extends JsonSchemaTypeRegistry<Schema> = JsonSchemaTypeRegistry<Schema>> extends BaseTypeManager<Schema, Registry, JsonSchemaTypeManager<Schema, Registry>> {
+    /**
+     * get type name
+     * @param typeSchema
+     * @returns
+     */
+    protected getTypeNameFromSchema(typeSchema: Schema): string;
+    constructor();
+    /**
+     * Get TypeRegistries based on the current parentType
+     */
+    getTypeRegistriesWithParentType: (parentType?: string) => Registry[];
+    /**
+     * Get the deepest child field of a field
+     * Array<Array<String>> -> String
+     */
+    getTypeSchemaDeepChildField: (type: Schema) => Schema;
+    /**
+     * Get the plain text display string of the type schema, for example:
+     * Array<Array<String>>, Map<String, Number>
+     */
+    getComplexText: (type: Schema) => string;
+    getDisplayIcon: (type: Schema) => React$1.JSX.Element;
+    getTypeSchemaProperties: (type: Schema) => Record<string, Schema> | undefined;
+    getJsonPaths: (type: Schema) => string[] | undefined;
+}
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+type JsonSchemaBasicType = 'boolean' | 'string' | 'integer' | 'number' | 'object' | 'array' | 'map';
+interface IJsonSchema<T = string> {
+    type?: T;
+    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;
+        weak?: boolean;
+        formComponent?: string;
+        [key: string]: any;
+    };
+}
+type IBasicJsonSchema = IJsonSchema<JsonSchemaBasicType>;
+/**
+ * TypeRegistry based on IJsonSchema
+ */
+interface JsonSchemaTypeRegistry<Schema extends Partial<IJsonSchema> = IJsonSchema> extends BaseTypeRegistry {
+    /**
+     * The icon of this type
+     */
+    icon: React.JSX.Element;
+    /**
+     * 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[];
+    getSupportedItemTypes?: (ctx: {
+        level: number;
+        parentTypes?: string[];
+    }) => Array<{
+        type: string;
+        disabled?: string;
+    }>;
+    /**
+     * Get the display label
+     */
+    getDisplayLabel: (typeSchema: Schema) => React.JSX.Element;
+    /**
+     * 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) => JSX.Element;
+    /**
+     * 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;
+}
+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>;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare 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.
+     */
+    function schemaToAST(jsonSchema: IJsonSchema): ASTNodeJSON | undefined;
+    /**
+     * Convert AST To JSON Schema
+     * @param typeAST
+     * @returns
+     */
+    function astToSchema(typeAST?: ASTNode, options?: {
+        drilldown?: boolean;
+        drilldownObject?: boolean;
+        drilldownMap?: boolean;
+        drilldownArray?: boolean;
+    }): IJsonSchema | undefined;
+    /**
+     * Check if the AST type is match the JSON Schema
+     * @param typeAST
+     * @param schema
+     * @returns
+     */
+    function isASTMatchSchema(typeAST: BaseType, schema: IJsonSchema | IJsonSchema[]): boolean;
+}
+
+declare const jsonSchemaTypeManager: JsonSchemaTypeManager<IJsonSchema<string>, JsonSchemaTypeRegistry<IJsonSchema<string>>>;
+
+declare const useTypeManager: () => JsonSchemaTypeManager<IJsonSchema<string>, JsonSchemaTypeRegistry<IJsonSchema<string>>> | BaseTypeManager<unknown, BaseTypeRegistry, BaseTypeManager<unknown, BaseTypeRegistry, BaseTypeManager<unknown, BaseTypeRegistry, BaseTypeManager<any, any, any>>>>;
+declare const TypePresetProvider: <Registry extends JsonSchemaTypeRegistry = JsonSchemaTypeRegistry>({ children, types, }: React$1.PropsWithChildren<{
+    types: (Partial<Registry> | TypeRegistryCreator<IJsonSchema, Registry, JsonSchemaTypeManager<IJsonSchema, Registry>>)[];
+}>) => React$1.JSX.Element;
+
+/**
+ * Copyright (c) 2025 Bytedance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ */
+
+declare const jsonSchemaContainerModule: ContainerModule;
+
+export { BaseTypeManager, type BaseTypeRegistry, type IBasicJsonSchema, type IJsonSchema, type JsonSchemaBasicType, JsonSchemaTypeManager, type JsonSchemaTypeRegistry, type JsonSchemaTypeRegistryCreator, JsonSchemaUtils, TypePresetProvider, type TypeRegistryCreator, jsonSchemaContainerModule, jsonSchemaTypeManager, useTypeManager };