@tachybase/schema 0.23.41 → 0.23.48

package/lib/json-schema/polyfills/SPECIFICATION_1_0.js

@@ -0,0 +1,132 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SPECIFICATION_1_0_exports = {};
+__export(SPECIFICATION_1_0_exports, {
+  registerTypeDefaultComponents: () => registerTypeDefaultComponents,
+  registerVoidComponents: () => registerVoidComponents
+});
+module.exports = __toCommonJS(SPECIFICATION_1_0_exports);
+var import_shared = require("../../shared");
+var import_patches = require("../patches");
+const VOID_COMPONENTS = ["card", "block", "grid-col", "grid-row", "grid", "layout", "step", "tab", "text-box"];
+const TYPE_DEFAULT_COMPONENTS = {};
+const transformCondition = /* @__PURE__ */ __name((condition) => {
+  if ((0, import_shared.isStr)(condition)) {
+    return condition.replace(/\$value/, "$self.value");
+  }
+}, "transformCondition");
+const transformXLinkage = /* @__PURE__ */ __name((linkages) => {
+  if ((0, import_shared.isArr)(linkages)) {
+    return linkages.reduce((buf, item) => {
+      if (!item) return buf;
+      if (item.type === "value:visible") {
+        return buf.concat({
+          target: item.target,
+          when: transformCondition(item.condition),
+          fulfill: {
+            state: {
+              visible: true
+            }
+          },
+          otherwise: {
+            state: {
+              visible: false
+            }
+          }
+        });
+      } else if (item.type === "value:schema") {
+        return buf.concat({
+          target: item.target,
+          when: transformCondition(item.condition),
+          fulfill: {
+            schema: SpecificationV1Polyfill({ version: "1.0", ...item.schema })
+          },
+          otherwise: {
+            schema: SpecificationV1Polyfill({
+              version: "1.0",
+              ...item.otherwise
+            })
+          }
+        });
+      } else if (item.type === "value:state") {
+        return buf.concat({
+          target: item.target,
+          when: transformCondition(item.condition),
+          fulfill: {
+            state: item.state
+          },
+          otherwise: {
+            state: item.otherwise
+          }
+        });
+      }
+    }, []);
+  }
+  return [];
+}, "transformXLinkage");
+const SpecificationV1Polyfill = /* @__PURE__ */ __name((schema) => {
+  if ((0, import_shared.isValid)(schema["editable"])) {
+    schema["x-editable"] = schema["x-editable"] || schema["editable"];
+    delete schema["editable"];
+  }
+  if ((0, import_shared.isValid)(schema["visible"])) {
+    schema["x-visible"] = schema["x-visible"] || schema["visible"];
+    delete schema["visible"];
+  }
+  if ((0, import_shared.isValid)(schema["display"])) {
+    schema["x-display"] = schema["x-display"] || (schema["display"] ? "visible" : "hidden");
+    delete schema["display"];
+  }
+  if ((0, import_shared.isValid)(schema["x-props"])) {
+    schema["x-decorator-props"] = schema["x-decorator-props"] || schema["x-props"];
+    delete schema["display"];
+  }
+  if (schema["x-linkages"]) {
+    schema["x-reactions"] = (0, import_shared.toArr)(schema["x-reactions"]).concat(transformXLinkage(schema["x-linkages"]));
+    delete schema["x-linkages"];
+  }
+  if (schema["x-component"]) {
+    if (VOID_COMPONENTS.some((component) => (0, import_shared.lowerCase)(component) === (0, import_shared.lowerCase)(schema["x-component"]))) {
+      schema["type"] = "void";
+    }
+  } else {
+    if (TYPE_DEFAULT_COMPONENTS[schema["type"]]) {
+      schema["x-component"] = TYPE_DEFAULT_COMPONENTS[schema["type"]];
+    }
+  }
+  if (!schema["x-decorator"] && schema["type"] !== "void" && schema["type"] !== "object") {
+    schema["x-decorator"] = schema["x-decorator"] || "FormItem";
+  }
+  if (schema["x-rules"]) {
+    schema["x-validator"] = [].concat(schema["x-validator"] || []).concat(schema["x-rules"]);
+  }
+  return schema;
+}, "SpecificationV1Polyfill");
+(0, import_patches.registerPolyfills)("1.0", SpecificationV1Polyfill);
+const registerVoidComponents = /* @__PURE__ */ __name((components) => {
+  VOID_COMPONENTS.push(...components);
+}, "registerVoidComponents");
+const registerTypeDefaultComponents = /* @__PURE__ */ __name((maps) => {
+  Object.assign(TYPE_DEFAULT_COMPONENTS, maps);
+}, "registerTypeDefaultComponents");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerTypeDefaultComponents,
+  registerVoidComponents
+});

package/lib/json-schema/polyfills/index.d.ts

@@ -0,0 +1 @@
+export * from './SPECIFICATION_1_0';

package/lib/json-schema/polyfills/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var polyfills_exports = {};
+module.exports = __toCommonJS(polyfills_exports);
+__reExport(polyfills_exports, require("./SPECIFICATION_1_0"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./SPECIFICATION_1_0")
+});

package/lib/json-schema/schema.d.ts

@@ -0,0 +1,88 @@
+import { IFieldFactoryProps } from '../core';
+import { ISchema, ISchemaTransformerOptions, SchemaEnum, SchemaKey, SchemaProperties, SchemaReaction, SchemaTypes } from './types';
+export declare class Schema<Decorator = any, Component = any, DecoratorProps = any, ComponentProps = any, Pattern = any, Display = any, Validator = any, Message = any, ReactionField = any> implements ISchema {
+    parent?: Schema;
+    root?: Schema;
+    name?: SchemaKey;
+    title?: Message;
+    description?: Message;
+    default?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    type?: SchemaTypes;
+    enum?: SchemaEnum<Message>;
+    const?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string | RegExp;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[] | boolean | string;
+    format?: string;
+    /** nested json schema spec **/
+    definitions?: Record<string, Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>>;
+    properties?: Record<string, Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>>;
+    items?: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message> | Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>[];
+    additionalItems?: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    patternProperties?: Record<string, Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>>;
+    additionalProperties?: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    ['x-index']?: number;
+    ['x-pattern']?: Pattern;
+    ['x-display']?: Display;
+    ['x-validator']?: Validator;
+    ['x-decorator']?: Decorator;
+    ['x-decorator-props']?: DecoratorProps;
+    ['x-component']?: Component;
+    ['x-component-props']?: ComponentProps;
+    ['x-reactions']?: SchemaReaction<ReactionField>[];
+    ['x-content']?: any;
+    ['x-data']?: any;
+    ['x-visible']?: boolean;
+    ['x-hidden']?: boolean;
+    ['x-disabled']?: boolean;
+    ['x-editable']?: boolean;
+    ['x-read-only']?: boolean;
+    ['x-read-pretty']?: boolean;
+    ['x-compile-omitted']?: string[];
+    [key: `x-${string | number}` | symbol]: any;
+    _isJSONSchemaObject: boolean;
+    version: string;
+    constructor(json: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>, parent?: Schema);
+    addProperty: (key: SchemaKey, schema: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    removeProperty: (key: SchemaKey) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    setProperties: (properties: SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => this;
+    addPatternProperty: (key: SchemaKey, schema: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    removePatternProperty: (key: SchemaKey) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    setPatternProperties: (properties: SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => this;
+    setAdditionalProperties: (properties: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    setItems: (schema: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message> | ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>[]) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any> | Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>[];
+    setAdditionalItems: (items: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message, any>;
+    findDefinitions: (ref: string) => any;
+    mapProperties: <T>(callback?: (schema: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>, key: SchemaKey, index: number) => T) => T[];
+    mapPatternProperties: <T>(callback?: (schema: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>, key: SchemaKey, index: number) => T) => T[];
+    reduceProperties: <P, R>(callback?: (buffer: P, schema: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>, key: SchemaKey, index: number) => R, predicate?: P) => R;
+    reducePatternProperties: <P, R>(callback?: (buffer: P, schema: Schema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>, key: SchemaKey, index: number) => R, predicate?: P) => R;
+    compile: (scope?: any) => Schema<any, any, any, any, any, any, any, any, any>;
+    fromJSON: (json: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>) => Schema<any, any, any, any, any, any, any, any, any>;
+    toJSON: (recursion?: boolean) => ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    toFieldProps: (options?: ISchemaTransformerOptions) => IFieldFactoryProps<any, any>;
+    static getOrderProperties: (schema?: ISchema, propertiesName?: keyof ISchema) => any[];
+    static compile: (expression: any, scope?: any) => any;
+    static shallowCompile: (expression: any, scope?: any) => any;
+    static isSchemaInstance: (value: any) => value is Schema;
+    static registerCompiler: (compiler: (expression: string, scope: any) => any) => void;
+    static registerPatches: (...args: import("./types").SchemaPatch[]) => void;
+    static registerVoidComponents: (components: string[]) => void;
+    static registerTypeDefaultComponents: (maps: Record<string, string>) => void;
+    static registerPolyfills: (version: string, patch: import("./types").SchemaPatch) => void;
+    static enablePolyfills: (versions?: string[]) => void;
+    static silent: (value?: boolean) => void;
+}

package/lib/json-schema/schema.js

@@ -0,0 +1,231 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  Schema: () => Schema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_shared = require("../shared");
+var import_compiler = require("./compiler");
+var import_patches = require("./patches");
+var import_polyfills = require("./polyfills");
+var import_shared2 = require("./shared");
+var import_transformer = require("./transformer");
+const _Schema = class _Schema {
+  constructor(json, parent) {
+    this._isJSONSchemaObject = true;
+    this.version = "2.0";
+    this.addProperty = /* @__PURE__ */ __name((key, schema) => {
+      this.properties = this.properties || {};
+      this.properties[key] = new _Schema(schema, this);
+      this.properties[key].name = key;
+      return this.properties[key];
+    }, "addProperty");
+    this.removeProperty = /* @__PURE__ */ __name((key) => {
+      const schema = this.properties[key];
+      delete this.properties[key];
+      return schema;
+    }, "removeProperty");
+    this.setProperties = /* @__PURE__ */ __name((properties) => {
+      for (const key in properties) {
+        this.addProperty(key, properties[key]);
+      }
+      return this;
+    }, "setProperties");
+    this.addPatternProperty = /* @__PURE__ */ __name((key, schema) => {
+      if (!schema) return;
+      this.patternProperties = this.patternProperties || {};
+      this.patternProperties[key] = new _Schema(schema, this);
+      this.patternProperties[key].name = key;
+      return this.patternProperties[key];
+    }, "addPatternProperty");
+    this.removePatternProperty = /* @__PURE__ */ __name((key) => {
+      const schema = this.patternProperties[key];
+      delete this.patternProperties[key];
+      return schema;
+    }, "removePatternProperty");
+    this.setPatternProperties = /* @__PURE__ */ __name((properties) => {
+      if (!properties) return this;
+      for (const key in properties) {
+        this.addPatternProperty(key, properties[key]);
+      }
+      return this;
+    }, "setPatternProperties");
+    this.setAdditionalProperties = /* @__PURE__ */ __name((properties) => {
+      if (!properties) return;
+      this.additionalProperties = new _Schema(properties);
+      return this.additionalProperties;
+    }, "setAdditionalProperties");
+    this.setItems = /* @__PURE__ */ __name((schema) => {
+      if (!schema) return;
+      if (Array.isArray(schema)) {
+        this.items = schema.map((item) => new _Schema(item, this));
+      } else {
+        this.items = new _Schema(schema, this);
+      }
+      return this.items;
+    }, "setItems");
+    this.setAdditionalItems = /* @__PURE__ */ __name((items) => {
+      if (!items) return;
+      this.additionalItems = new _Schema(items, this);
+      return this.additionalItems;
+    }, "setAdditionalItems");
+    this.findDefinitions = /* @__PURE__ */ __name((ref) => {
+      if (!ref || !this.root || !(0, import_shared.isStr)(ref)) return;
+      if (ref.indexOf("#/") !== 0) return;
+      return import_shared.FormPath.getIn(this.root, ref.substring(2).split("/"));
+    }, "findDefinitions");
+    this.mapProperties = /* @__PURE__ */ __name((callback) => {
+      return _Schema.getOrderProperties(this).map(({ schema, key }, index) => {
+        return callback(schema, key, index);
+      });
+    }, "mapProperties");
+    this.mapPatternProperties = /* @__PURE__ */ __name((callback) => {
+      return _Schema.getOrderProperties(this, "patternProperties").map(({ schema, key }, index) => {
+        return callback(schema, key, index);
+      });
+    }, "mapPatternProperties");
+    this.reduceProperties = /* @__PURE__ */ __name((callback, predicate) => {
+      let results = predicate;
+      _Schema.getOrderProperties(this, "properties").forEach(({ schema, key }, index) => {
+        results = callback(results, schema, key, index);
+      });
+      return results;
+    }, "reduceProperties");
+    this.reducePatternProperties = /* @__PURE__ */ __name((callback, predicate) => {
+      let results = predicate;
+      _Schema.getOrderProperties(this, "patternProperties").forEach(({ schema, key }, index) => {
+        results = callback(results, schema, key, index);
+      });
+      return results;
+    }, "reducePatternProperties");
+    this.compile = /* @__PURE__ */ __name((scope) => {
+      const schema = new _Schema({}, this.parent);
+      (0, import_shared.each)(this, (value, key) => {
+        if ((0, import_shared.isFn)(value) && !key.includes("x-")) return;
+        if (key === "parent" || key === "root") return;
+        if (!import_shared2.SchemaNestedMap[key]) {
+          schema[key] = value ? (0, import_compiler.compile)(value, scope) : value;
+        } else {
+          schema[key] = value ? (0, import_compiler.shallowCompile)(value, scope) : value;
+        }
+      });
+      return schema;
+    }, "compile");
+    this.fromJSON = /* @__PURE__ */ __name((json) => {
+      if (!json) return this;
+      if (_Schema.isSchemaInstance(json)) return json;
+      (0, import_shared.each)((0, import_patches.reducePatches)(json), (value, key) => {
+        if ((0, import_shared.isFn)(value) && !key.includes("x-")) return;
+        if (key === "properties") {
+          this.setProperties(value);
+        } else if (key === "patternProperties") {
+          this.setPatternProperties(value);
+        } else if (key === "additionalProperties") {
+          this.setAdditionalProperties(value);
+        } else if (key === "items") {
+          this.setItems(value);
+        } else if (key === "additionalItems") {
+          this.setAdditionalItems(value);
+        } else if (key === "$ref") {
+          this.fromJSON(this.findDefinitions(value));
+        } else {
+          this[key] = value;
+        }
+      });
+      return this;
+    }, "fromJSON");
+    this.toJSON = /* @__PURE__ */ __name((recursion = true) => {
+      const results = {};
+      (0, import_shared.each)(this, (value, key) => {
+        var _a, _b;
+        if ((0, import_shared.isFn)(value) && !key.includes("x-") || key === "parent" || key === "root") return;
+        if (key === "properties" || key === "patternProperties") {
+          if (!recursion) return;
+          results[key] = (0, import_shared.map)(value, (item) => {
+            var _a2;
+            return (_a2 = item == null ? void 0 : item.toJSON) == null ? void 0 : _a2.call(item);
+          });
+        } else if (key === "additionalProperties" || key === "additionalItems") {
+          if (!recursion) return;
+          results[key] = (_a = value == null ? void 0 : value.toJSON) == null ? void 0 : _a.call(value);
+        } else if (key === "items") {
+          if (!recursion) return;
+          if (Array.isArray(value)) {
+            results[key] = value.map((item) => {
+              var _a2;
+              return (_a2 = item == null ? void 0 : item.toJSON) == null ? void 0 : _a2.call(item);
+            });
+          } else {
+            results[key] = (_b = value == null ? void 0 : value.toJSON) == null ? void 0 : _b.call(value);
+          }
+        } else {
+          results[key] = value;
+        }
+      });
+      return results;
+    }, "toJSON");
+    this.toFieldProps = /* @__PURE__ */ __name((options) => {
+      return (0, import_transformer.transformFieldProps)(this, options);
+    }, "toFieldProps");
+    if (parent) {
+      this.parent = parent;
+      this.root = parent.root;
+    } else {
+      this.root = this;
+    }
+    return this.fromJSON(json);
+  }
+};
+__name(_Schema, "Schema");
+_Schema.getOrderProperties = /* @__PURE__ */ __name((schema = {}, propertiesName = "properties") => {
+  const orderProperties = [];
+  const unorderProperties = [];
+  for (const key in schema[propertiesName]) {
+    const item = schema[propertiesName][key];
+    const index = item["x-index"];
+    if (!isNaN(index)) {
+      orderProperties[index] = { schema: item, key };
+    } else {
+      unorderProperties.push({ schema: item, key });
+    }
+  }
+  return orderProperties.concat(unorderProperties).filter((item) => !!item);
+}, "getOrderProperties");
+_Schema.compile = /* @__PURE__ */ __name((expression, scope) => {
+  return (0, import_compiler.compile)(expression, scope);
+}, "compile");
+_Schema.shallowCompile = /* @__PURE__ */ __name((expression, scope) => {
+  return (0, import_compiler.shallowCompile)(expression, scope);
+}, "shallowCompile");
+_Schema.isSchemaInstance = /* @__PURE__ */ __name((value) => {
+  return (0, import_shared.instOf)(value, _Schema);
+}, "isSchemaInstance");
+_Schema.registerCompiler = import_compiler.registerCompiler;
+_Schema.registerPatches = import_patches.registerPatches;
+_Schema.registerVoidComponents = import_polyfills.registerVoidComponents;
+_Schema.registerTypeDefaultComponents = import_polyfills.registerTypeDefaultComponents;
+_Schema.registerPolyfills = import_patches.registerPolyfills;
+_Schema.enablePolyfills = import_patches.enablePolyfills;
+_Schema.silent = import_compiler.silent;
+let Schema = _Schema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Schema
+});

package/lib/json-schema/shared.d.ts

@@ -0,0 +1,62 @@
+import { ISchema } from './types';
+export declare const SchemaNestedMap: {
+    parent: boolean;
+    root: boolean;
+    properties: boolean;
+    patternProperties: boolean;
+    additionalProperties: boolean;
+    items: boolean;
+    additionalItems: boolean;
+    'x-linkages': boolean;
+    'x-reactions': boolean;
+};
+export declare const SchemaStateMap: {
+    title: string;
+    description: string;
+    default: string;
+    enum: string;
+    readOnly: string;
+    writeOnly: string;
+    'x-content': string;
+    'x-data': string;
+    'x-value': string;
+    'x-editable': string;
+    'x-disabled': string;
+    'x-read-pretty': string;
+    'x-read-only': string;
+    'x-visible': string;
+    'x-hidden': string;
+    'x-display': string;
+    'x-pattern': string;
+    'x-validator': string;
+    'x-decorator': string;
+    'x-component': string;
+    'x-decorator-props': string;
+    'x-component-props': string;
+};
+export declare const SchemaValidatorMap: {
+    required: boolean;
+    format: boolean;
+    maxItems: boolean;
+    minItems: boolean;
+    maxLength: boolean;
+    minLength: boolean;
+    maximum: boolean;
+    minimum: boolean;
+    exclusiveMaximum: boolean;
+    exclusiveMinimum: boolean;
+    pattern: boolean;
+    const: boolean;
+    multipleOf: boolean;
+    maxProperties: boolean;
+    minProperties: boolean;
+    uniqueItems: boolean;
+};
+export declare const SchemaNormalKeys: string[];
+export declare const SchemaValidatorKeys: string[];
+export declare const hasOwnProperty: (v: PropertyKey) => boolean;
+export declare const traverse: (target: any, visitor: (value: any, path: Array<string | number>) => void) => void;
+export declare const traverseSchema: (schema: ISchema, visitor: (value: any, path: any[], omitCompile?: boolean) => void) => void;
+export declare const isNoNeedCompileObject: (source: any) => boolean;
+export declare const createDataSource: (source: any[]) => any[];
+export declare const patchStateFormSchema: (targetState: any, pattern: any[], compiled: any) => void;