@tachybase/schema 0.23.40 → 0.23.47

package/lib/path/types.d.ts

@@ -0,0 +1,88 @@
+import { Path } from './index';
+interface INode {
+    type?: string;
+    after?: Node;
+    depth?: number;
+}
+export type Node = IdentifierNode | WildcardOperatorNode | GroupExpressionNode | RangeExpressionNode | DestructorExpressionNode | ObjectPatternNode | ArrayPatternNode | DotOperatorNode | ExpandOperatorNode | INode;
+export type IdentifierNode = {
+    type: 'Identifier';
+    value: string;
+    arrayIndex?: boolean;
+} & INode;
+export type IgnoreExpressionNode = {
+    type: 'IgnoreExpression';
+    value: string;
+} & INode;
+export type DotOperatorNode = {
+    type: 'DotOperator';
+} & INode;
+export type WildcardOperatorNode = {
+    type: 'WildcardOperator';
+    filter?: GroupExpressionNode | RangeExpressionNode;
+    optional?: boolean;
+} & INode;
+export type ExpandOperatorNode = {
+    type: 'ExpandOperator';
+} & INode;
+export type GroupExpressionNode = {
+    type: 'GroupExpression';
+    value: Node[];
+    isExclude?: boolean;
+} & INode;
+export type RangeExpressionNode = {
+    type: 'RangeExpression';
+    start?: IdentifierNode;
+    end?: IdentifierNode;
+} & INode;
+export type DestructorExpressionNode = {
+    type: 'DestructorExpression';
+    value?: ObjectPatternNode | ArrayPatternNode;
+    source?: string;
+} & INode;
+export type ObjectPatternNode = {
+    type: 'ObjectPattern';
+    properties: ObjectPatternPropertyNode[];
+} & INode;
+export type ObjectPatternPropertyNode = {
+    type: 'ObjectPatternProperty';
+    key: IdentifierNode;
+    value?: ObjectPatternNode[] | ArrayPatternNode[] | IdentifierNode;
+} & INode;
+export type ArrayPatternNode = {
+    type: 'ArrayPattern';
+    elements: ObjectPatternNode[] | ArrayPatternNode[] | IdentifierNode[];
+} & INode;
+export type DestructorRule = {
+    key?: string | number;
+    path?: Array<number | string>;
+};
+export type MatcherFunction = ((path: Segments) => boolean) & {
+    path: Path;
+};
+export type Pattern = string | number | Path | Segments | MatcherFunction | RegExp;
+export type DestructorRules = DestructorRule[];
+export type Segments = Array<string | number>;
+export declare const isType: <T>(type: string) => (obj: any) => obj is T;
+export declare const isIdentifier: (obj: any) => obj is IdentifierNode;
+export declare const isIgnoreExpression: (obj: any) => obj is IgnoreExpressionNode;
+export declare const isDotOperator: (obj: any) => obj is DotOperatorNode;
+export declare const isWildcardOperator: (obj: any) => obj is WildcardOperatorNode;
+export declare const isExpandOperator: (obj: any) => obj is ExpandOperatorNode;
+export declare const isGroupExpression: (obj: any) => obj is GroupExpressionNode;
+export declare const isRangeExpression: (obj: any) => obj is RangeExpressionNode;
+export declare const isDestructorExpression: (obj: any) => obj is DestructorExpressionNode;
+export declare const isObjectPattern: (obj: any) => obj is ObjectPatternNode;
+export declare const isObjectPatternProperty: (obj: any) => obj is ObjectPatternPropertyNode;
+export declare const isArrayPattern: (obj: any) => obj is ArrayPatternNode;
+export type KeyType = string | number | symbol;
+export type IAccessors = {
+    get?: (source: any, key: KeyType) => any;
+    set?: (source: any, key: KeyType, value: any) => any;
+    has?: (source: any, key: KeyType) => boolean;
+    delete?: (source: any, key: KeyType) => any;
+};
+export type IRegistry = {
+    accessors?: IAccessors;
+};
+export {};

package/lib/path/types.js

@@ -0,0 +1,63 @@
+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 types_exports = {};
+__export(types_exports, {
+  isArrayPattern: () => isArrayPattern,
+  isDestructorExpression: () => isDestructorExpression,
+  isDotOperator: () => isDotOperator,
+  isExpandOperator: () => isExpandOperator,
+  isGroupExpression: () => isGroupExpression,
+  isIdentifier: () => isIdentifier,
+  isIgnoreExpression: () => isIgnoreExpression,
+  isObjectPattern: () => isObjectPattern,
+  isObjectPatternProperty: () => isObjectPatternProperty,
+  isRangeExpression: () => isRangeExpression,
+  isType: () => isType,
+  isWildcardOperator: () => isWildcardOperator
+});
+module.exports = __toCommonJS(types_exports);
+const isType = /* @__PURE__ */ __name((type) => (obj) => {
+  return obj && obj.type === type;
+}, "isType");
+const isIdentifier = isType("Identifier");
+const isIgnoreExpression = isType("IgnoreExpression");
+const isDotOperator = isType("DotOperator");
+const isWildcardOperator = isType("WildcardOperator");
+const isExpandOperator = isType("ExpandOperator");
+const isGroupExpression = isType("GroupExpression");
+const isRangeExpression = isType("RangeExpression");
+const isDestructorExpression = isType("DestructorExpression");
+const isObjectPattern = isType("ObjectPattern");
+const isObjectPatternProperty = isType("ObjectPatternProperty");
+const isArrayPattern = isType("ArrayPattern");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isArrayPattern,
+  isDestructorExpression,
+  isDotOperator,
+  isExpandOperator,
+  isGroupExpression,
+  isIdentifier,
+  isIgnoreExpression,
+  isObjectPattern,
+  isObjectPatternProperty,
+  isRangeExpression,
+  isType,
+  isWildcardOperator
+});

package/lib/react/components/ArrayField.d.ts

@@ -0,0 +1,6 @@
+import { ArrayField as ArrayFieldType } from '../../core';
+import { IFieldProps, JSXComponent } from '../types';
+export declare const ArrayField: {
+    <D extends JSXComponent, C extends JSXComponent>(props: IFieldProps<D, C, ArrayFieldType>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/react/components/ArrayField.js

@@ -0,0 +1,44 @@
+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 ArrayField_exports = {};
+__export(ArrayField_exports, {
+  ArrayField: () => ArrayField
+});
+module.exports = __toCommonJS(ArrayField_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_hooks = require("../hooks");
+var import_useAttach = require("../hooks/useAttach");
+var import_shared = require("../shared");
+var import_ReactiveField = require("./ReactiveField");
+const ArrayField = /* @__PURE__ */ __name((props) => {
+  const form = (0, import_hooks.useForm)();
+  const parent = (0, import_hooks.useField)();
+  const field = (0, import_useAttach.useAttach)(
+    form.createArrayField({
+      basePath: parent == null ? void 0 : parent.address,
+      ...props
+    })
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.FieldContext.Provider, { value: field, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ReactiveField.ReactiveField, { field, children: props.children }) });
+}, "ArrayField");
+ArrayField.displayName = "ArrayField";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArrayField
+});

package/lib/react/components/ExpressionScope.d.ts

@@ -0,0 +1,2 @@
+import { IExpressionScopeProps, ReactFC } from '../types';
+export declare const ExpressionScope: ReactFC<IExpressionScopeProps>;

package/lib/react/components/ExpressionScope.js

@@ -0,0 +1,35 @@
+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 ExpressionScope_exports = {};
+__export(ExpressionScope_exports, {
+  ExpressionScope: () => ExpressionScope
+});
+module.exports = __toCommonJS(ExpressionScope_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_shared = require("../../shared");
+var import_shared2 = require("../shared");
+const ExpressionScope = /* @__PURE__ */ __name((props) => {
+  const scope = (0, import_react.useContext)(import_shared2.SchemaExpressionScopeContext);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared2.SchemaExpressionScopeContext.Provider, { value: (0, import_shared.lazyMerge)(scope, props.value), children: props.children });
+}, "ExpressionScope");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExpressionScope
+});

package/lib/react/components/Field.d.ts

@@ -0,0 +1,5 @@
+import { IFieldProps, JSXComponent } from '../types';
+export declare const Field: {
+    <D extends JSXComponent, C extends JSXComponent>(props: IFieldProps<D, C>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/react/components/Field.js

@@ -0,0 +1,45 @@
+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 Field_exports = {};
+__export(Field_exports, {
+  Field: () => Field
+});
+module.exports = __toCommonJS(Field_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_hooks = require("../hooks");
+var import_shared = require("../shared");
+var import_ReactiveField = require("./ReactiveField");
+const Field = /* @__PURE__ */ __name((props) => {
+  const form = (0, import_hooks.useForm)();
+  const parent = (0, import_hooks.useField)();
+  const field = form.createField({ basePath: parent == null ? void 0 : parent.address, ...props });
+  (0, import_react.useEffect)(() => {
+    field == null ? void 0 : field.onMount();
+    return () => {
+      field == null ? void 0 : field.onUnmount();
+    };
+  }, [field]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.FieldContext.Provider, { value: field, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ReactiveField.ReactiveField, { field, children: props.children }) });
+}, "Field");
+Field.displayName = "Field";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Field
+});

package/lib/react/components/FormConsumer.d.ts

@@ -0,0 +1,2 @@
+import { IFormSpyProps, ReactFC } from '../types';
+export declare const FormConsumer: ReactFC<IFormSpyProps>;

package/lib/react/components/FormConsumer.js

@@ -0,0 +1,36 @@
+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 FormConsumer_exports = {};
+__export(FormConsumer_exports, {
+  FormConsumer: () => FormConsumer
+});
+module.exports = __toCommonJS(FormConsumer_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = require("react");
+var import_reactive_react = require("../../reactive-react");
+var import_shared = require("../../shared");
+var import_hooks = require("../hooks");
+const FormConsumer = (0, import_reactive_react.observer)((props) => {
+  const children = (0, import_shared.isFn)(props.children) ? props.children((0, import_hooks.useForm)()) : null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Fragment, { children });
+});
+FormConsumer.displayName = "FormConsumer";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormConsumer
+});

package/lib/react/components/FormProvider.d.ts

@@ -0,0 +1,2 @@
+import { IProviderProps, ReactFC } from '../types';
+export declare const FormProvider: ReactFC<IProviderProps>;

package/lib/react/components/FormProvider.js

@@ -0,0 +1,35 @@
+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 FormProvider_exports = {};
+__export(FormProvider_exports, {
+  FormProvider: () => FormProvider
+});
+module.exports = __toCommonJS(FormProvider_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_useAttach = require("../hooks/useAttach");
+var import_shared = require("../shared");
+const FormProvider = /* @__PURE__ */ __name((props) => {
+  const form = (0, import_useAttach.useAttach)(props.form);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.ContextCleaner, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.FormContext.Provider, { value: form, children: props.children }) });
+}, "FormProvider");
+FormProvider.displayName = "FormProvider";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormProvider
+});

package/lib/react/components/ObjectField.d.ts

@@ -0,0 +1,6 @@
+import { ObjectField as ObjectFieldType } from '../../core';
+import { IFieldProps, JSXComponent } from '../types';
+export declare const ObjectField: {
+    <D extends JSXComponent, C extends JSXComponent>(props: IFieldProps<D, C, ObjectFieldType>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/lib/react/components/ObjectField.js

@@ -0,0 +1,39 @@
+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 ObjectField_exports = {};
+__export(ObjectField_exports, {
+  ObjectField: () => ObjectField
+});
+module.exports = __toCommonJS(ObjectField_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_hooks = require("../hooks");
+var import_useAttach = require("../hooks/useAttach");
+var import_shared = require("../shared");
+var import_ReactiveField = require("./ReactiveField");
+const ObjectField = /* @__PURE__ */ __name((props) => {
+  const form = (0, import_hooks.useForm)();
+  const parent = (0, import_hooks.useField)();
+  const field = (0, import_useAttach.useAttach)(form.createObjectField({ basePath: parent == null ? void 0 : parent.address, ...props }));
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_shared.FieldContext.Provider, { value: field, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ReactiveField.ReactiveField, { field, children: props.children }) });
+}, "ObjectField");
+ObjectField.displayName = "ObjectField";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectField
+});

package/lib/react/components/ReactiveField.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { GeneralField } from '../../core';
+import { RenderPropsChildren } from '../types';
+interface IReactiveFieldProps {
+    field: GeneralField;
+    children?: RenderPropsChildren<GeneralField>;
+}
+export declare const ReactiveField: React.MemoExoticComponent<import("..").ReactFC<IReactiveFieldProps & {
+    ref?: React.RefAttributes<any>;
+}>>;
+export {};

package/lib/react/components/ReactiveField.js

@@ -0,0 +1,115 @@
+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 ReactiveField_exports = {};
+__export(ReactiveField_exports, {
+  ReactiveField: () => ReactiveField
+});
+module.exports = __toCommonJS(ReactiveField_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react = __toESM(require("react"));
+var import_core = require("../../core");
+var import_reactive = require("../../reactive");
+var import_reactive_react = require("../../reactive-react");
+var import_shared = require("../../shared");
+var import_shared2 = require("../shared");
+const mergeChildren = /* @__PURE__ */ __name((children, content) => {
+  if (!children && !content) return;
+  if ((0, import_shared.isFn)(children)) return;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react.Fragment, { children: [
+    children,
+    content
+  ] });
+}, "mergeChildren");
+const isValidComponent = /* @__PURE__ */ __name((target) => target && (typeof target === "object" || typeof target === "function"), "isValidComponent");
+const renderChildren = /* @__PURE__ */ __name((children, field, form) => (0, import_shared.isFn)(children) ? children(field, form) : children, "renderChildren");
+const ReactiveInternal = /* @__PURE__ */ __name((props) => {
+  const components = (0, import_react.useContext)(import_shared2.SchemaComponentsContext);
+  if (!props.field) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Fragment, { children: renderChildren(props.children) });
+  }
+  const field = props.field;
+  const content = mergeChildren(
+    renderChildren(props.children, field, field.form),
+    field.content ?? field.componentProps.children
+  );
+  if (field.display !== "visible") return null;
+  const getComponent = /* @__PURE__ */ __name((target) => {
+    return isValidComponent(target) ? target : import_shared.FormPath.getIn(components, target) ?? target;
+  }, "getComponent");
+  const renderDecorator = /* @__PURE__ */ __name((children) => {
+    if (!field.decoratorType) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react.Fragment, { children });
+    }
+    return import_react.default.createElement(getComponent(field.decoratorType), (0, import_reactive.toJS)(field.decoratorProps), children);
+  }, "renderDecorator");
+  const renderComponent = /* @__PURE__ */ __name(() => {
+    var _a, _b, _c;
+    if (!field.componentType) return content;
+    const value = !(0, import_core.isVoidField)(field) ? field.value : void 0;
+    const onChange = !(0, import_core.isVoidField)(field) ? (...args) => {
+      var _a2, _b2;
+      field.onInput(...args);
+      (_b2 = (_a2 = field.componentProps) == null ? void 0 : _a2.onChange) == null ? void 0 : _b2.call(_a2, ...args);
+    } : (_a = field.componentProps) == null ? void 0 : _a.onChange;
+    const onFocus = !(0, import_core.isVoidField)(field) ? (...args) => {
+      var _a2, _b2;
+      field.onFocus(...args);
+      (_b2 = (_a2 = field.componentProps) == null ? void 0 : _a2.onFocus) == null ? void 0 : _b2.call(_a2, ...args);
+    } : (_b = field.componentProps) == null ? void 0 : _b.onFocus;
+    const onBlur = !(0, import_core.isVoidField)(field) ? (...args) => {
+      var _a2, _b2;
+      field.onBlur(...args);
+      (_b2 = (_a2 = field.componentProps) == null ? void 0 : _a2.onBlur) == null ? void 0 : _b2.call(_a2, ...args);
+    } : (_c = field.componentProps) == null ? void 0 : _c.onBlur;
+    const disabled = !(0, import_core.isVoidField)(field) ? field.pattern === "disabled" || field.pattern === "readPretty" : void 0;
+    const readOnly = !(0, import_core.isVoidField)(field) ? field.pattern === "readOnly" : void 0;
+    return import_react.default.createElement(
+      getComponent(field.componentType),
+      {
+        disabled,
+        readOnly,
+        ...(0, import_reactive.toJS)(field.componentProps),
+        value,
+        onChange,
+        onFocus,
+        onBlur
+      },
+      content
+    );
+  }, "renderComponent");
+  return renderDecorator(renderComponent());
+}, "ReactiveInternal");
+ReactiveInternal.displayName = "ReactiveField";
+const ReactiveField = (0, import_reactive_react.observer)(ReactiveInternal, {
+  forwardRef: true
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReactiveField
+});

package/lib/react/components/RecordScope.d.ts

@@ -0,0 +1,2 @@
+import { IRecordScopeProps, ReactFC } from '../types';
+export declare const RecordScope: ReactFC<IRecordScopeProps>;

package/lib/react/components/RecordScope.js

@@ -0,0 +1,65 @@
+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 RecordScope_exports = {};
+__export(RecordScope_exports, {
+  RecordScope: () => RecordScope
+});
+module.exports = __toCommonJS(RecordScope_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_shared = require("../../shared");
+var import_hooks = require("../hooks");
+var import_ExpressionScope = require("./ExpressionScope");
+const RecordScope = /* @__PURE__ */ __name((props) => {
+  const scope = (0, import_hooks.useExpressionScope)();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_ExpressionScope.ExpressionScope,
+    {
+      value: {
+        get $lookup() {
+          return scope == null ? void 0 : scope.$record;
+        },
+        get $record() {
+          var _a;
+          const record = (_a = props.getRecord) == null ? void 0 : _a.call(props);
+          if (typeof record === "object") {
+            return (0, import_shared.lazyMerge)(record, {
+              get $lookup() {
+                return scope == null ? void 0 : scope.$record;
+              },
+              get $index() {
+                var _a2;
+                return (_a2 = props.getIndex) == null ? void 0 : _a2.call(props);
+              }
+            });
+          }
+          return record;
+        },
+        get $index() {
+          var _a;
+          return (_a = props.getIndex) == null ? void 0 : _a.call(props);
+        }
+      },
+      children: props.children
+    }
+  );
+}, "RecordScope");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RecordScope
+});

package/lib/react/components/RecordsScope.d.ts

@@ -0,0 +1,2 @@
+import { IRecordsScopeProps, ReactFC } from '../types';
+export declare const RecordsScope: ReactFC<IRecordsScopeProps>;