@tachybase/schema 0.23.41 → 0.23.47

package/lib/react/hooks/useForm.js

@@ -0,0 +1,32 @@
+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 useForm_exports = {};
+__export(useForm_exports, {
+  useForm: () => useForm
+});
+module.exports = __toCommonJS(useForm_exports);
+var import_react = require("react");
+var import_shared = require("../shared");
+const useForm = /* @__PURE__ */ __name(() => {
+  return (0, import_react.useContext)(import_shared.FormContext);
+}, "useForm");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useForm
+});

package/lib/react/hooks/useFormEffects.d.ts

@@ -0,0 +1,2 @@
+import { Form } from '../../core';
+export declare const useFormEffects: (effects?: (form: Form) => void) => void;

package/lib/react/hooks/useFormEffects.js

@@ -0,0 +1,42 @@
+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 useFormEffects_exports = {};
+__export(useFormEffects_exports, {
+  useFormEffects: () => useFormEffects
+});
+module.exports = __toCommonJS(useFormEffects_exports);
+var import_reactive_react = require("../../reactive-react");
+var import_shared = require("../../shared");
+var import_useForm = require("./useForm");
+const useFormEffects = /* @__PURE__ */ __name((effects) => {
+  const form = (0, import_useForm.useForm)();
+  (0, import_reactive_react.unstable_useCompatFactory)(() => {
+    const id = (0, import_shared.uid)();
+    form.addEffects(id, effects);
+    return {
+      dispose() {
+        form.removeEffects(id);
+      }
+    };
+  });
+}, "useFormEffects");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFormEffects
+});

package/lib/react/hooks/useParentForm.d.ts

@@ -0,0 +1,2 @@
+import { Form, ObjectField } from '../../core';
+export declare const useParentForm: () => Form | ObjectField;

package/lib/react/hooks/useParentForm.js

@@ -0,0 +1,40 @@
+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 useParentForm_exports = {};
+__export(useParentForm_exports, {
+  useParentForm: () => useParentForm
+});
+module.exports = __toCommonJS(useParentForm_exports);
+var import_core = require("../../core");
+var import_useField = require("./useField");
+var import_useForm = require("./useForm");
+const useParentForm = /* @__PURE__ */ __name(() => {
+  const field = (0, import_useField.useField)();
+  const form = (0, import_useForm.useForm)();
+  const findObjectParent = /* @__PURE__ */ __name((field2) => {
+    if (!field2) return form;
+    if ((0, import_core.isObjectField)(field2)) return field2;
+    return findObjectParent(field2 == null ? void 0 : field2.parent);
+  }, "findObjectParent");
+  return findObjectParent(field);
+}, "useParentForm");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useParentForm
+});

package/lib/react/index.d.ts

@@ -0,0 +1,5 @@
+export * from '../json-schema';
+export * from './components';
+export * from './shared';
+export * from './hooks';
+export * from './types';

package/lib/react/index.js

@@ -0,0 +1,29 @@
+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 react_exports = {};
+module.exports = __toCommonJS(react_exports);
+__reExport(react_exports, require("../json-schema"), module.exports);
+__reExport(react_exports, require("./components"), module.exports);
+__reExport(react_exports, require("./shared"), module.exports);
+__reExport(react_exports, require("./hooks"), module.exports);
+__reExport(react_exports, require("./types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("../json-schema"),
+  ...require("./components"),
+  ...require("./shared"),
+  ...require("./hooks"),
+  ...require("./types")
+});

package/lib/react/shared/connect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { observer, Observer } from '../../reactive-react';
+import { IComponentMapper, IStateMapper, JSXComponent } from '../types';
+export declare function mapProps<T extends JSXComponent>(...args: IStateMapper<React.ComponentProps<T>>[]): (target: T) => React.MemoExoticComponent<import("..").ReactFC<any>>;
+export declare function mapReadPretty<T extends JSXComponent, C extends JSXComponent>(component: C, readPrettyProps?: React.ComponentProps<C>): (target: T) => React.MemoExoticComponent<import("..").ReactFC<{
+    ref?: React.RefAttributes<any>;
+}>>;
+export declare function connect<T extends JSXComponent>(target: T, ...args: IComponentMapper<T>[]): React.ForwardRefExoticComponent<React.PropsWithoutRef<React.ComponentProps<T>> & React.RefAttributes<React.ElementRef<T>>>;
+export { observer, Observer };

package/lib/react/shared/connect.js

@@ -0,0 +1,118 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var connect_exports = {};
+__export(connect_exports, {
+  Observer: () => import_reactive_react.Observer,
+  connect: () => connect,
+  mapProps: () => mapProps,
+  mapReadPretty: () => mapReadPretty,
+  observer: () => import_reactive_react.observer
+});
+module.exports = __toCommonJS(connect_exports);
+var import_react = __toESM(require("react"));
+var import_hoist_non_react_statics = __toESM(require("hoist-non-react-statics"));
+var import_core = require("../../core");
+var import_reactive_react = require("../../reactive-react");
+var import_shared = require("../../shared");
+var import_hooks = require("../hooks");
+function mapProps(...args) {
+  return (target) => {
+    return (0, import_reactive_react.observer)(
+      (props) => {
+        const field = (0, import_hooks.useField)();
+        const results = args.reduce(
+          (props2, mapper) => {
+            if ((0, import_shared.isFn)(mapper)) {
+              props2 = Object.assign(props2, mapper(props2, field));
+            } else {
+              (0, import_shared.each)(mapper, (to, extract) => {
+                const extractValue = import_shared.FormPath.getIn(field, extract);
+                const targetValue = (0, import_shared.isStr)(to) ? to : extract;
+                const originalValue = import_shared.FormPath.getIn(props2, targetValue);
+                if (extract === "value") {
+                  if (to !== extract) {
+                    delete props2.value;
+                  }
+                }
+                if ((0, import_shared.isValid)(originalValue) && !(0, import_shared.isValid)(extractValue)) return;
+                import_shared.FormPath.setIn(props2, targetValue, extractValue);
+              });
+            }
+            return props2;
+          },
+          { ...props }
+        );
+        return import_react.default.createElement(target, results);
+      },
+      {
+        forwardRef: true
+      }
+    );
+  };
+}
+__name(mapProps, "mapProps");
+function mapReadPretty(component, readPrettyProps) {
+  return (target) => {
+    return (0, import_reactive_react.observer)(
+      (props) => {
+        const field = (0, import_hooks.useField)();
+        if (!(0, import_core.isVoidField)(field) && (field == null ? void 0 : field.pattern) === "readPretty") {
+          return import_react.default.createElement(component, {
+            ...readPrettyProps,
+            ...props
+          });
+        }
+        return import_react.default.createElement(target, props);
+      },
+      {
+        forwardRef: true
+      }
+    );
+  };
+}
+__name(mapReadPretty, "mapReadPretty");
+function connect(target, ...args) {
+  const Target = args.reduce((target2, mapper) => {
+    return mapper(target2);
+  }, target);
+  const Destination = import_react.default.forwardRef((props, ref) => {
+    return import_react.default.createElement(Target, { ...props, ref });
+  });
+  if (target) (0, import_hoist_non_react_statics.default)(Destination, target);
+  return Destination;
+}
+__name(connect, "connect");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Observer,
+  connect,
+  mapProps,
+  mapReadPretty,
+  observer
+});

package/lib/react/shared/context.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Form, GeneralField } from '../../core';
+import { Schema } from '../../json-schema';
+import { ISchemaFieldReactFactoryOptions, SchemaReactComponents } from '../types';
+export declare const FormContext: React.Context<Form<any>>;
+export declare const FieldContext: React.Context<GeneralField>;
+export declare const SchemaMarkupContext: React.Context<Schema<any, any, any, any, any, any, any, any, any>>;
+export declare const SchemaContext: React.Context<Schema<any, any, any, any, any, any, any, any, any>>;
+export declare const SchemaExpressionScopeContext: React.Context<any>;
+export declare const SchemaComponentsContext: React.Context<SchemaReactComponents>;
+export declare const SchemaOptionsContext: React.Context<ISchemaFieldReactFactoryOptions<any>>;
+export declare const ContextCleaner: ({ children }: {
+    children: any;
+}) => any;

package/lib/react/shared/context.js

@@ -0,0 +1,74 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  ContextCleaner: () => ContextCleaner,
+  FieldContext: () => FieldContext,
+  FormContext: () => FormContext,
+  SchemaComponentsContext: () => SchemaComponentsContext,
+  SchemaContext: () => SchemaContext,
+  SchemaExpressionScopeContext: () => SchemaExpressionScopeContext,
+  SchemaMarkupContext: () => SchemaMarkupContext,
+  SchemaOptionsContext: () => SchemaOptionsContext
+});
+module.exports = __toCommonJS(context_exports);
+var import_react = __toESM(require("react"));
+const createContextCleaner = /* @__PURE__ */ __name((...contexts) => {
+  return ({ children }) => {
+    return contexts.reduce((buf, ctx) => {
+      return import_react.default.createElement(ctx.Provider, { value: void 0 }, buf);
+    }, children);
+  };
+}, "createContextCleaner");
+const FormContext = (0, import_react.createContext)(null);
+const FieldContext = (0, import_react.createContext)(null);
+const SchemaMarkupContext = (0, import_react.createContext)(null);
+const SchemaContext = (0, import_react.createContext)(null);
+const SchemaExpressionScopeContext = (0, import_react.createContext)(null);
+const SchemaComponentsContext = (0, import_react.createContext)(null);
+const SchemaOptionsContext = (0, import_react.createContext)(null);
+const ContextCleaner = createContextCleaner(
+  FieldContext,
+  SchemaMarkupContext,
+  SchemaContext,
+  SchemaExpressionScopeContext,
+  SchemaComponentsContext,
+  SchemaOptionsContext
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextCleaner,
+  FieldContext,
+  FormContext,
+  SchemaComponentsContext,
+  SchemaContext,
+  SchemaExpressionScopeContext,
+  SchemaMarkupContext,
+  SchemaOptionsContext
+});

package/lib/react/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './context';
+export * from './connect';

package/lib/react/shared/index.js

@@ -0,0 +1,23 @@
+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 shared_exports = {};
+module.exports = __toCommonJS(shared_exports);
+__reExport(shared_exports, require("./context"), module.exports);
+__reExport(shared_exports, require("./connect"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./context"),
+  ...require("./connect")
+});

package/lib/react/shared/render.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const render: (element: React.ReactElement) => React.ReactPortal | React.DetailedReactHTMLElement<{}, HTMLElement>;

package/lib/react/shared/render.js

@@ -0,0 +1,69 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+__export(render_exports, {
+  render: () => render
+});
+module.exports = __toCommonJS(render_exports);
+var import_react = __toESM(require("react"));
+var import_shared = require("../../shared");
+var _a, _b, _c, _d, _e;
+const env = {
+  portalDOM: (_c = (_b = (_a = import_shared.globalThisPolyfill) == null ? void 0 : _a.document) == null ? void 0 : _b.createElement) == null ? void 0 : _c.call(_b, "div"),
+  createPortal: (_e = (_d = import_shared.globalThisPolyfill) == null ? void 0 : _d["ReactDOM"]) == null ? void 0 : _e.createPortal
+};
+const loadCreatePortal = /* @__PURE__ */ __name(() => {
+  var _a2;
+  if (!env.createPortal) {
+    try {
+      env.createPortal ??= (_a2 = require("react-dom")) == null ? void 0 : _a2.createPortal;
+    } catch {
+    }
+  }
+  if (!env.createPortal) {
+    try {
+      import("react-dom").then((module2) => env.createPortal ??= module2 == null ? void 0 : module2.createPortal).catch();
+    } catch {
+    }
+  }
+}, "loadCreatePortal");
+const render = /* @__PURE__ */ __name((element) => {
+  var _a2;
+  if (((_a2 = import_shared.globalThisPolyfill.navigator) == null ? void 0 : _a2.product) === "ReactNative") return null;
+  if (env.portalDOM && env.createPortal) {
+    return env.createPortal(element, env.portalDOM);
+  } else {
+    return import_react.default.createElement("template", {}, element);
+  }
+}, "render");
+loadCreatePortal();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  render
+});

package/lib/react/types.d.ts

@@ -0,0 +1,84 @@
+import React from 'react';
+import { FieldDisplayTypes, Field as FieldType, FieldValidator, Form, FormPatternTypes, GeneralField, IFieldFactoryProps, IVoidFieldFactoryProps, ObjectField, VoidField } from '../core';
+import { ISchema, Schema, SchemaKey } from '../json-schema';
+import { ReactFC } from '../reactive-react';
+import { FormPathPattern } from '../shared';
+export type JSXComponent = keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>;
+export type IProviderProps = {
+    form: Form;
+};
+export interface IFormSpyProps {
+    children?: (form: Form) => ReactChild;
+}
+export type RenderPropsChildren<Payload> = ((field: Payload, form: Form) => React.ReactNode) | React.ReactNode;
+export interface IFieldProps<D extends JSXComponent, C extends JSXComponent, Field = FieldType> extends IFieldFactoryProps<D, C> {
+    children?: RenderPropsChildren<Field>;
+    decorator?: [] | [D] | [D, React.ComponentProps<D>] | any[];
+    component?: [] | [C] | [C, React.ComponentProps<C>] | any[];
+}
+export interface IVoidFieldProps<D extends JSXComponent, C extends JSXComponent, Field = VoidField> extends IVoidFieldFactoryProps<D, C> {
+    children?: RenderPropsChildren<Field>;
+    decorator?: [] | [D] | [D, React.ComponentProps<D>] | any[];
+    component?: [] | [C] | [C, React.ComponentProps<C>] | any[];
+}
+export interface IComponentMapper<T extends JSXComponent> {
+    (target: T): JSXComponent;
+}
+export type IStateMapper<Props> = {
+    [key in keyof FieldType]?: keyof Props | boolean;
+} | ((props: Props, field: GeneralField) => Props);
+export type SchemaReactComponents = Record<string, JSXComponent>;
+export interface ISchemaFieldReactFactoryOptions<Components extends SchemaReactComponents = any> {
+    components?: Components;
+    scope?: any;
+}
+export interface ISchemaFieldOptionContext {
+    components: SchemaReactComponents;
+}
+export interface ISchemaFieldProps<Decorator extends JSXComponent = any, Component extends JSXComponent = any, InnerField = ObjectField<Decorator, Component>> extends Omit<IFieldFactoryProps<Decorator, Component, InnerField>, 'name'> {
+    schema?: ISchema;
+    components?: {
+        [key: string]: JSXComponent;
+    };
+    scope?: any;
+    name?: SchemaKey;
+    children?: React.ReactNode;
+}
+export interface ISchemaMapper {
+    (schema: Schema, name: SchemaKey): Schema;
+}
+export interface ISchemaFilter {
+    (schema: Schema, name: SchemaKey): boolean;
+}
+export interface IRecursionFieldProps {
+    schema: ISchema;
+    name?: SchemaKey;
+    basePath?: FormPathPattern;
+    propsRecursion?: boolean;
+    onlyRenderProperties?: boolean;
+    onlyRenderSelf?: boolean;
+    mapProperties?: ISchemaMapper;
+    filterProperties?: ISchemaFilter;
+}
+export type ObjectKey = string | number | boolean | symbol;
+export type Path<T, Key extends keyof T = keyof T> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${Path<T[Key], Exclude<keyof T[Key], keyof Array<any>>> & string}` | `${Key}.${Exclude<keyof T[Key], keyof Array<any>> & string}` | Key : Key : never;
+export type PathValue<T, P extends Path<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path<T[Key]> ? PathValue<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+export type KeyOfReactComponent<T> = Exclude<keyof T, 'contextTypes' | 'displayName' | 'propTypes' | 'defaultProps'>;
+export type ReactComponentPath<T, Key extends KeyOfReactComponent<T> = KeyOfReactComponent<T>> = Key extends string ? T[Key] extends Record<string, any> ? `${Key}.${Exclude<KeyOfReactComponent<T[Key]>, keyof Array<any>> & string}` | Key : Key : never;
+export type ReactComponentPropsByPathValue<T extends Record<string, any>, P extends ReactComponentPath<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends ReactComponentPath<T[Key]> ? ReactComponentPropsByPathValue<T[Key], Rest> : never : React.ComponentProps<T[P]> : P extends keyof T ? React.ComponentProps<T[P]> : never;
+export interface ISchemaMarkupFieldProps<Components extends SchemaReactComponents, Decorator extends ReactComponentPath<Components>, Component extends ReactComponentPath<Components>> extends ISchema<Decorator, Component, ReactComponentPropsByPathValue<Components, Decorator>, ReactComponentPropsByPathValue<Components, Component>, FormPatternTypes, FieldDisplayTypes, FieldValidator, React.ReactNode, GeneralField> {
+    children?: React.ReactNode;
+}
+export type ISchemaTypeFieldProps<Components extends SchemaReactComponents, Decorator extends ReactComponentPath<Components>, Component extends ReactComponentPath<Components>> = ISchemaMarkupFieldProps<Components, Decorator, Component>;
+export interface IExpressionScopeProps {
+    value?: any;
+}
+export interface IRecordScopeProps {
+    getIndex?(): number;
+    getRecord(): any;
+}
+export interface IRecordsScopeProps {
+    getRecords(): any[];
+}
+export type ReactChild = React.ReactElement | string | number;
+export { type ReactFC };

package/lib/react/types.js

@@ -0,0 +1,15 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/reactive/action.d.ts

@@ -0,0 +1,2 @@
+import { IAction } from './types';
+export declare const action: IAction;

package/lib/reactive/action.js

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 action_exports = {};
+__export(action_exports, {
+  action: () => action
+});
+module.exports = __toCommonJS(action_exports);
+var import_internals = require("./internals");
+var import_reaction = require("./reaction");
+const action = (0, import_internals.createBoundaryAnnotation)(
+  () => {
+    (0, import_reaction.batchStart)();
+    (0, import_reaction.untrackStart)();
+  },
+  () => {
+    (0, import_reaction.untrackEnd)();
+    (0, import_reaction.batchEnd)();
+  }
+);
+action.scope = (0, import_internals.createBoundaryAnnotation)(
+  () => {
+    (0, import_reaction.batchScopeStart)();
+    (0, import_reaction.untrackStart)();
+  },
+  () => {
+    (0, import_reaction.untrackEnd)();
+    (0, import_reaction.batchScopeEnd)();
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  action
+});

package/lib/reactive/annotations/box.d.ts

@@ -0,0 +1,7 @@
+export interface IBox {
+    <T>(target: T): {
+        get(): T;
+        set(value: T): void;
+    };
+}
+export declare const box: IBox;