@react-typed-forms/schemas 3.0.0-dev.73

package/.rush/temp/package-deps_build.json

@@ -0,0 +1,13 @@
+{
+  "files": {
+    "packages/schemas/.rush/temp/shrinkwrap-deps.json": "6ad43bbf71e5f191d9f571da269a25bb4d9e8909",
+    "packages/schemas/package.json": "44b7bc4a5f4b4edcde168265b086fe71f0921d97",
+    "packages/schemas/src/controlRender.tsx": "277603b8bb9ced9263547455c6a38c9ce56930a6",
+    "packages/schemas/src/hooks.ts": "64cf3ef2b5151231c9ffbc26da34002a3cab867d",
+    "packages/schemas/src/index.ts": "b15fbb6de132cd912cf8141d5c4d2329e947546e",
+    "packages/schemas/src/schemaBuilder.ts": "3a36cbc35f70fca2b561f6d4ddc1bd1030eeb3f6",
+    "packages/schemas/src/types.ts": "88168cc68de0d9784e0e60430bee4d084ee3fa68",
+    "packages/schemas/tsconfig.json": "52e4f044fa580f4e0ad5830f3cfca574e2788372"
+  },
+  "arguments": "rimraf ./lib/ && tsc "
+}

package/.rush/temp/shrinkwrap-deps.json

@@ -0,0 +1,25 @@
+{
+  "../../packages/schemas": "../../packages/schemas:vY3D5bPwBzOGJtSnpoQLPVXnewF01wtTbcozE4xaygA=:",
+  "/@types/prop-types/15.7.5": "sha512-JCB8C6SnDoQf0cNycqd/35A7MjcnK+ZTqE7judS6o7utxUCg6imJg3QK2qzHKszlTjcj2cn+NwMB2i96ubpj7w==",
+  "/@types/react/18.0.22": "sha512-4yWc5PyCkZN8ke8K9rQHkTXxHIWHxLzzW6RI1kXVoepkD3vULpKzC2sDtAMKn78h92BRYuzf+7b/ms7ajE6hFw==",
+  "/@types/scheduler/0.16.2": "sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==",
+  "/balanced-match/1.0.2": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+  "/brace-expansion/1.1.11": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+  "/concat-map/0.0.1": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=",
+  "/csstype/3.0.11": "sha512-sa6P2wJ+CAbgyy4KFssIb/JNMLxFvKF1pCYCSXS8ZMuqZnMsrxqI2E5sPyoTpxoPU/gVZMzr2zjOfg8GIZOMsw==",
+  "/fs.realpath/1.0.0": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=",
+  "/glob/7.2.0": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+  "/inflight/1.0.6": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=",
+  "/inherits/2.0.4": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+  "/js-tokens/4.0.0": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+  "/loose-envify/1.4.0": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+  "/minimatch/3.1.2": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+  "/nswag/13.18.2": "sha512-7OpG9WkrZUO2+9I7hgQsaAHujsP/tCaIs7ML2B4wUuFLjSsG6lHucyrREyVO/h9l3MM/Cw4RlEGFBbluWhgeYg==",
+  "/once/1.4.0": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+  "/path-is-absolute/1.0.1": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=",
+  "/react-dom/18.2.0_react@18.2.0": "sha512-6IMTriUmvsjHUjNtEDudZfuDQUoWXVxKHhlEGSk81n4YFS+r/Kl99wXiwlVXtPBtJenozv2P+hxDsw9eA7Xo6g==",
+  "/react/18.2.0": "sha512-/3IjMdb2L9QbBdWiW5e3P2/npwMBaU9mHCSCUzNln0ZCYbcfTsGbTJrU/kGemdH2IWmB2ioZ+zkxtmq6g09fGQ==",
+  "/rimraf/3.0.2": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+  "/scheduler/0.23.0": "sha512-CtuThmgHNg7zIZWAXi3AsyIzA3n4xx7aNyjwC2VJldO2LMVDhFK+63xGqq6CsJH4rTAt6/M+N4GhZiDYPx9eUw==",
+  "/wrappy/1.0.2": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+}

package/lib/controlRender.d.ts

@@ -0,0 +1,94 @@
+import { ActionControlDefinition, AnyControlDefinition, CompoundField, ControlDefinition, DataControlDefinition, DisplayControlDefinition, FieldOption, GroupedControlsDefinition, ScalarField, SchemaField } from "./types";
+import React, { Key, ReactElement } from "react";
+import { AnyControl, Control } from "@react-typed-forms/core";
+export interface FormEditHooks {
+    useDataProperties(formState: FormEditState, definition: DataControlDefinition, field: ScalarField): DataControlProperties;
+    useGroupProperties(formState: FormEditState, definition: GroupedControlsDefinition, currentHooks: FormEditHooks): GroupControlProperties;
+    useDisplayProperties(formState: FormEditState, definition: DisplayControlDefinition): DisplayControlProperties;
+    useActionProperties(formState: FormEditState, definition: ActionControlDefinition): ActionControlProperties;
+}
+export interface DataControlProperties {
+    visible: boolean;
+    options: FieldOption[] | undefined;
+    defaultValue: any;
+    required: boolean;
+    customRender?: (props: DataRendererProps) => ReactElement;
+}
+export interface GroupControlProperties {
+    visible: boolean;
+    hooks: FormEditHooks;
+}
+export interface DisplayControlProperties {
+    visible: boolean;
+}
+export interface ActionControlProperties {
+    visible: boolean;
+    onClick: () => void;
+}
+export interface ControlData {
+    [field: string]: any;
+}
+export interface FormEditState {
+    fields: SchemaField[];
+    data: Control<ControlData>;
+}
+export interface FormRendererComponents {
+    renderData: (props: DataRendererProps) => ReactElement;
+    renderGroup: (props: GroupRendererProps) => ReactElement;
+    renderCompound: (props: CompoundGroupRendererProps) => ReactElement;
+    renderDisplay: (props: DisplayRendererProps) => ReactElement;
+    renderAction: (props: ActionRendererProps) => ReactElement;
+}
+export declare const FormRendererComponentsContext: React.Context<FormRendererComponents | undefined>;
+export declare function useFormRendererComponents(): FormRendererComponents;
+export interface DisplayRendererProps {
+    definition: DisplayControlDefinition;
+    properties: DisplayControlProperties;
+}
+export interface ActionRendererProps {
+    definition: ActionControlDefinition;
+    properties: ActionControlProperties;
+}
+export interface DataRendererProps {
+    definition: DataControlDefinition;
+    properties: DataControlProperties;
+    field: ScalarField;
+    control: AnyControl;
+    formEditState?: FormEditState;
+}
+export interface GroupRendererProps {
+    definition: Omit<GroupedControlsDefinition, "children">;
+    properties: GroupControlProperties;
+    childCount: number;
+    renderChild: (child: number, wrapChild: (key: Key, childElem: ReactElement) => ReactElement) => ReactElement;
+}
+export interface CompoundGroupRendererProps {
+    definition: GroupedControlsDefinition;
+    field: CompoundField;
+    control: AnyControl;
+    properties: GroupControlProperties;
+    renderChild: (key: Key, control: ControlDefinition, data: Control<{
+        [field: string]: any;
+    }>, wrapChild: (key: Key, childElem: ReactElement) => ReactElement) => ReactElement;
+}
+export declare function isScalarField(sf: SchemaField): sf is ScalarField;
+export declare function isCompoundField(sf: SchemaField): sf is CompoundField;
+export type AnySchemaFields = SchemaField | ScalarField | (Omit<CompoundField, "children"> & {
+    children: AnySchemaFields[];
+});
+export declare function applyDefaultValues(v: {
+    [k: string]: any;
+} | undefined, fields: SchemaField[]): any;
+export declare function applyDefaultForField(v: any, field: SchemaField, parent: SchemaField[], notElement?: boolean): any;
+export declare function defaultValueForFields(fields: SchemaField[]): any;
+export declare function defaultValueForField(sf: SchemaField, notElement?: boolean): any;
+export declare function findScalarField(fields: SchemaField[], field: string): ScalarField | undefined;
+export declare function findCompoundField(fields: SchemaField[], field: string): CompoundField | undefined;
+export declare function findField(fields: SchemaField[], field: string): SchemaField | undefined;
+export declare function fieldDisplayName(sf: SchemaField): string;
+export declare function controlTitle(title: string | undefined, field: SchemaField): string;
+export declare function renderControl(definition: AnyControlDefinition, formState: FormEditState, hooks: FormEditHooks, key: Key, wrapChild?: (key: Key, db: ReactElement) => ReactElement): ReactElement;
+export declare function controlForField(field: string, formState: FormEditState): Control<any>;
+export declare function fieldForControl(c: ControlDefinition): string | undefined;
+export declare function isSchemaControl(c: ControlDefinition): c is DataControlDefinition;
+export declare function isGroupControl(c: ControlDefinition): c is GroupedControlsDefinition;

package/lib/controlRender.js

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGroupControl = exports.isSchemaControl = exports.fieldForControl = exports.controlForField = exports.renderControl = exports.controlTitle = exports.fieldDisplayName = exports.findField = exports.findCompoundField = exports.findScalarField = exports.defaultValueForField = exports.defaultValueForFields = exports.applyDefaultForField = exports.applyDefaultValues = exports.isCompoundField = exports.isScalarField = exports.useFormRendererComponents = exports.FormRendererComponentsContext = void 0;
+const types_1 = require("./types");
+const react_1 = __importStar(require("react"));
+const core_1 = require("@react-typed-forms/core");
+exports.FormRendererComponentsContext = (0, react_1.createContext)(undefined);
+function useFormRendererComponents() {
+    const c = (0, react_1.useContext)(exports.FormRendererComponentsContext);
+    if (!c) {
+        throw "Need to use FormRendererComponentContext.Provider";
+    }
+    return c;
+}
+exports.useFormRendererComponents = useFormRendererComponents;
+function isScalarField(sf) {
+    return sf.schemaType === types_1.SchemaFieldType.Scalar;
+}
+exports.isScalarField = isScalarField;
+function isCompoundField(sf) {
+    return sf.schemaType === types_1.SchemaFieldType.Compound;
+}
+exports.isCompoundField = isCompoundField;
+function applyDefaultValues(v, fields) {
+    if (!v)
+        return defaultValueForFields(fields);
+    const applyValue = fields.filter((x) => x.schemaType === types_1.SchemaFieldType.Compound || !(x.field in v));
+    if (!applyValue.length)
+        return v;
+    const out = Object.assign({}, v);
+    applyValue.forEach((x) => {
+        out[x.field] =
+            x.field in v
+                ? applyDefaultForField(v[x.field], x, fields)
+                : defaultValueForField(x, true);
+    });
+    return out;
+}
+exports.applyDefaultValues = applyDefaultValues;
+function applyDefaultForField(v, field, parent, notElement) {
+    var _a;
+    if (field.collection && !notElement) {
+        return ((_a = v) !== null && _a !== void 0 ? _a : []).map((x) => applyDefaultForField(x, field, parent, true));
+    }
+    if (isCompoundField(field)) {
+        return applyDefaultValues(v, field.treeChildren ? parent : field.children);
+    }
+    return defaultValueForField(field, true);
+}
+exports.applyDefaultForField = applyDefaultForField;
+function defaultValueForFields(fields) {
+    return Object.fromEntries(fields.map((x) => [x.field, defaultValueForField(x, true)]));
+}
+exports.defaultValueForFields = defaultValueForFields;
+function defaultValueForField(sf, notElement) {
+    if (notElement && sf.collection)
+        return [];
+    if (isCompoundField(sf)) {
+        return defaultValueForFields(sf.children);
+    }
+    return sf.defaultValue;
+}
+exports.defaultValueForField = defaultValueForField;
+function findScalarField(fields, field) {
+    return findField(fields, field);
+}
+exports.findScalarField = findScalarField;
+function findCompoundField(fields, field) {
+    return findField(fields, field);
+}
+exports.findCompoundField = findCompoundField;
+function findField(fields, field) {
+    return fields.find((x) => x.field === field);
+}
+exports.findField = findField;
+function fieldDisplayName(sf) {
+    return sf.displayName ? sf.displayName : sf.field;
+}
+exports.fieldDisplayName = fieldDisplayName;
+function controlTitle(title, field) {
+    return title ? title : fieldDisplayName(field);
+}
+exports.controlTitle = controlTitle;
+function renderControl(definition, formState, hooks, key, wrapChild) {
+    const { fields } = formState;
+    switch (definition.type) {
+        case types_1.ControlDefinitionType.Data:
+            const def = definition;
+            const fieldData = findScalarField(fields, def.field);
+            if (!fieldData)
+                return react_1.default.createElement("h1", null,
+                    "No schema field for: ",
+                    def.field);
+            return (react_1.default.createElement(DataRenderer, { key: key, wrapElem: wrapElem, formState: formState, hooks: hooks, controlDef: def, fieldData: fieldData }));
+        case types_1.ControlDefinitionType.Group:
+            return (react_1.default.createElement(GroupRenderer, { key: key, hooks: hooks, groupDef: definition, formState: formState, wrapElem: wrapElem }));
+        case types_1.ControlDefinitionType.Display:
+            return (react_1.default.createElement(DisplayRenderer, { key: key, hooks: hooks, formState: formState, wrapElem: wrapElem, displayDef: definition }));
+        case types_1.ControlDefinitionType.Action:
+            return (react_1.default.createElement(ActionRenderer, { key: key, hooks: hooks, formState: formState, wrapElem: wrapElem, actionDef: definition }));
+        default:
+            return react_1.default.createElement("h1", null,
+                "Unknown control: ",
+                definition.type);
+    }
+    function wrapElem(e) {
+        var _a;
+        return (_a = wrapChild === null || wrapChild === void 0 ? void 0 : wrapChild(key, e)) !== null && _a !== void 0 ? _a : e;
+    }
+}
+exports.renderControl = renderControl;
+function DataRenderer({ hooks, formState, controlDef, wrapElem, fieldData, }) {
+    var _a, _b;
+    const { renderData } = useFormRendererComponents();
+    const props = hooks.useDataProperties(formState, controlDef, fieldData);
+    const scalarControl = (_a = formState.data.fields[fieldData.field]) !== null && _a !== void 0 ? _a : (0, core_1.newControl)(undefined);
+    (0, core_1.useControlChangeEffect)(scalarControl, (c) => {
+        if (props.defaultValue && !c.current.value) {
+            c.value = props.defaultValue;
+        }
+    }, core_1.ControlChange.Value, [scalarControl, props.defaultValue], true);
+    if (!props.visible) {
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    }
+    const scalarProps = {
+        formEditState: formState,
+        field: fieldData,
+        control: scalarControl,
+        definition: controlDef,
+        properties: props,
+    };
+    return wrapElem(((_b = props.customRender) !== null && _b !== void 0 ? _b : renderData)(scalarProps));
+}
+function ActionRenderer({ hooks, formState, wrapElem, actionDef, }) {
+    const { renderAction } = useFormRendererComponents();
+    const actionControlProperties = hooks.useActionProperties(formState, actionDef);
+    if (!actionControlProperties.visible) {
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    }
+    return wrapElem(renderAction({ definition: actionDef, properties: actionControlProperties }));
+}
+function GroupRenderer({ hooks, formState, groupDef, wrapElem, }) {
+    const { renderCompound, renderGroup } = useFormRendererComponents();
+    const groupProps = hooks.useGroupProperties(formState, groupDef, hooks);
+    if (!groupProps.visible) {
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    }
+    const compoundField = groupDef.compoundField
+        ? findCompoundField(formState.fields, groupDef.compoundField)
+        : undefined;
+    if (compoundField) {
+        return wrapElem(renderCompound({
+            definition: groupDef,
+            field: compoundField,
+            control: formState.data.fields[compoundField.field],
+            properties: groupProps,
+            renderChild: (k, c, data, wrapChild) => renderControl(c, Object.assign(Object.assign({}, formState), { fields: compoundField.children, data }), groupProps.hooks, k, wrapChild),
+        }));
+    }
+    return wrapElem(renderGroup({
+        definition: groupDef,
+        childCount: groupDef.children.length,
+        properties: groupProps,
+        renderChild: (c, wrapChild) => renderControl(groupDef.children[c], formState, groupProps.hooks, c, wrapChild),
+    }));
+}
+function DisplayRenderer({ hooks, wrapElem, formState, displayDef, }) {
+    const { renderDisplay } = useFormRendererComponents();
+    const displayProps = hooks.useDisplayProperties(formState, displayDef);
+    if (!displayProps.visible) {
+        return react_1.default.createElement(react_1.default.Fragment, null);
+    }
+    return wrapElem(renderDisplay({ definition: displayDef, properties: displayProps }));
+}
+function controlForField(field, formState) {
+    var _a;
+    const refField = findField(formState.fields, field);
+    return ((_a = (refField && formState.data.fields[refField.field])) !== null && _a !== void 0 ? _a : (0, core_1.newControl)(undefined));
+}
+exports.controlForField = controlForField;
+function fieldForControl(c) {
+    return isSchemaControl(c)
+        ? c.field
+        : isGroupControl(c)
+            ? c.compoundField
+            : undefined;
+}
+exports.fieldForControl = fieldForControl;
+function isSchemaControl(c) {
+    return c.type === types_1.ControlDefinitionType.Data;
+}
+exports.isSchemaControl = isSchemaControl;
+function isGroupControl(c) {
+    return c.type === types_1.ControlDefinitionType.Group;
+}
+exports.isGroupControl = isGroupControl;

package/lib/hooks.d.ts

@@ -0,0 +1,9 @@
+import { DataControlDefinition, EntityExpression, FieldOption, ScalarField, ControlDefinition } from "./types";
+import { DataControlProperties, FormEditHooks, FormEditState } from "./controlRender";
+export type ExpressionHook = (expr: EntityExpression, formState: FormEditState) => any;
+export declare function useDefaultValue(definition: DataControlDefinition, field: ScalarField, formState: FormEditState, useExpression: ExpressionHook): any;
+export declare function useIsControlVisible(definition: ControlDefinition, formState: FormEditState, useExpression: ExpressionHook): boolean;
+export declare function getDefaultScalarControlProperties(control: DataControlDefinition, field: ScalarField, visible: boolean, defaultValue: any): DataControlProperties;
+export declare function getOptionsForScalarField(field: ScalarField): FieldOption[] | undefined;
+export declare const defaultExpressionHook: ExpressionHook;
+export declare function createFormEditHooks(useExpression: ExpressionHook): FormEditHooks;

package/lib/hooks.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFormEditHooks = exports.defaultExpressionHook = exports.getOptionsForScalarField = exports.getDefaultScalarControlProperties = exports.useIsControlVisible = exports.useDefaultValue = void 0;
+const types_1 = require("./types");
+const controlRender_1 = require("./controlRender");
+const react_1 = require("react");
+const core_1 = require("@react-typed-forms/core");
+function useDefaultValue(definition, field, formState, useExpression) {
+    var _a;
+    const valueExpression = (_a = definition.dynamic) === null || _a === void 0 ? void 0 : _a.find((x) => x.type === types_1.DynamicPropertyType.DefaultValue);
+    if (valueExpression) {
+        return useExpression(valueExpression.expr, formState);
+    }
+    return field.defaultValue;
+}
+exports.useDefaultValue = useDefaultValue;
+function useIsControlVisible(definition, formState, useExpression) {
+    var _a, _b;
+    const visibleExpression = (_a = definition.dynamic) === null || _a === void 0 ? void 0 : _a.find((x) => x.type === types_1.DynamicPropertyType.Visible);
+    if (visibleExpression && visibleExpression.expr) {
+        return Boolean(useExpression(visibleExpression.expr, formState));
+    }
+    const schemaFields = formState.fields;
+    const typeControl = (0, react_1.useMemo)(() => {
+        var _a, _b;
+        const typeField = schemaFields.find((x) => (0, controlRender_1.isScalarField)(x) && x.isTypeField);
+        return ((_b = (typeField && ((_a = formState.data.fields) === null || _a === void 0 ? void 0 : _a[typeField.field]))) !== null && _b !== void 0 ? _b : (0, core_1.newControl)(undefined));
+    }, [schemaFields, formState.data]);
+    const fieldName = (0, controlRender_1.fieldForControl)(definition);
+    const onlyForTypes = (_b = (fieldName ? (0, controlRender_1.findField)(schemaFields, fieldName) : undefined)) === null || _b === void 0 ? void 0 : _b.onlyForTypes;
+    return (0, core_1.useControlValue)(() => !onlyForTypes ||
+        onlyForTypes.length === 0 ||
+        Boolean(typeControl.value && onlyForTypes.includes(typeControl.value)));
+}
+exports.useIsControlVisible = useIsControlVisible;
+function getDefaultScalarControlProperties(control, field, visible, defaultValue) {
+    return {
+        defaultValue,
+        options: getOptionsForScalarField(field),
+        required: control.required,
+        visible,
+    };
+}
+exports.getDefaultScalarControlProperties = getDefaultScalarControlProperties;
+function getOptionsForScalarField(field) {
+    var _a, _b;
+    const opts = (_a = field.restrictions) === null || _a === void 0 ? void 0 : _a.options;
+    if ((_b = opts === null || opts === void 0 ? void 0 : opts.length) !== null && _b !== void 0 ? _b : 0 > 0) {
+        return opts;
+    }
+    return undefined;
+}
+exports.getOptionsForScalarField = getOptionsForScalarField;
+const defaultExpressionHook = (expr, formState) => {
+    switch (expr.type) {
+        case types_1.ExpressionType.FieldValue:
+            const fvExpr = expr;
+            return (0, core_1.useControlValue)(() => (0, controlRender_1.controlForField)(fvExpr.field, formState).value === fvExpr.value);
+        default:
+            return undefined;
+    }
+};
+exports.defaultExpressionHook = defaultExpressionHook;
+function createFormEditHooks(useExpression) {
+    return {
+        useDataProperties(formState, definition, field) {
+            const visible = useIsControlVisible(definition, formState, useExpression);
+            const defaultValue = useDefaultValue(definition, field, formState, useExpression);
+            return getDefaultScalarControlProperties(definition, field, visible, defaultValue);
+        },
+        useDisplayProperties: (fs, definition) => {
+            const visible = useIsControlVisible(definition, fs, useExpression);
+            return { visible };
+        },
+        useGroupProperties: (fs, definition, hooks) => {
+            const visible = useIsControlVisible(definition, fs, useExpression);
+            return { visible, hooks };
+        },
+        useActionProperties(formState, definition) {
+            const visible = useIsControlVisible(definition, formState, useExpression);
+            return { visible, onClick: () => { } };
+        },
+    };
+}
+exports.createFormEditHooks = createFormEditHooks;

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./schemaBuilder";
+export * from "./controlRender";
+export * from "./hooks";

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./schemaBuilder"), exports);
+__exportStar(require("./controlRender"), exports);
+__exportStar(require("./hooks"), exports);

package/lib/schemaBuilder.d.ts

@@ -0,0 +1,107 @@
+import { CompoundField, FieldOption, FieldType, ScalarField, SchemaField, SchemaFieldType } from "./types";
+type AllowedSchema<T> = T extends string ? ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+    type: FieldType.String | FieldType.Date | FieldType.DateTime;
+} : T extends number ? ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+    type: FieldType.Int | FieldType.Double;
+} : T extends boolean ? ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+    type: FieldType.Bool;
+} : T extends Array<infer E> ? AllowedSchema<E> & {
+    collection: true;
+} : T extends {
+    [key: string]: any;
+} ? CompoundField & {
+    schemaType: SchemaFieldType.Compound;
+    type: FieldType.Compound;
+} : never;
+type AllowedField<T> = (name: string) => AllowedSchema<T>;
+export declare function buildSchema<T>(def: {
+    [K in keyof T]-?: AllowedField<T[K]>;
+}): SchemaField[];
+export declare function stringField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+} & {
+    field?: string | undefined;
+    displayName: string;
+    tags?: string[] | undefined;
+    system?: boolean | undefined;
+    collection?: boolean | undefined;
+    onlyForTypes?: string[] | undefined;
+    entityRefType?: string | undefined;
+    required?: boolean | undefined;
+    parentField?: string | undefined;
+    searchable?: boolean | undefined;
+    defaultValue?: any;
+    isTypeField?: boolean | undefined;
+    restrictions?: import("./types").SchemaRestrictions | undefined;
+    type: FieldType.String;
+};
+export declare function stringOptionsField(displayName: string, ...options: FieldOption[]): (name: string) => ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+} & {
+    type: FieldType.String;
+    displayName: string;
+    restrictions: {
+        options: FieldOption[];
+    };
+};
+export declare function withScalarOptions<S extends ScalarField>(options: Partial<ScalarField>, v: (name: string) => S): (name: string) => S;
+export declare function makeScalarField<S extends Partial<ScalarField>>(options: S): (name: string) => ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+} & S;
+export declare function makeCompoundField<S extends Partial<CompoundField>>(options: S): (name: string) => CompoundField & {
+    schemaType: SchemaFieldType.Compound;
+    type: FieldType.Compound;
+} & S;
+export declare function intField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+} & {
+    field?: string | undefined;
+    displayName: string;
+    tags?: string[] | undefined;
+    system?: boolean | undefined;
+    collection?: boolean | undefined;
+    onlyForTypes?: string[] | undefined;
+    entityRefType?: string | undefined;
+    required?: boolean | undefined;
+    parentField?: string | undefined;
+    searchable?: boolean | undefined;
+    defaultValue?: any;
+    isTypeField?: boolean | undefined;
+    restrictions?: import("./types").SchemaRestrictions | undefined;
+    type: FieldType.Int;
+};
+export declare function boolField(displayName: string, options?: Partial<Omit<ScalarField, "schemaType" | "type">>): (name: string) => ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+} & {
+    field?: string | undefined;
+    displayName: string;
+    tags?: string[] | undefined;
+    system?: boolean | undefined;
+    collection?: boolean | undefined;
+    onlyForTypes?: string[] | undefined;
+    entityRefType?: string | undefined;
+    required?: boolean | undefined;
+    parentField?: string | undefined;
+    searchable?: boolean | undefined;
+    defaultValue?: any;
+    isTypeField?: boolean | undefined;
+    restrictions?: import("./types").SchemaRestrictions | undefined;
+    type: FieldType.Bool;
+};
+export declare function compoundField<Other extends Partial<Omit<CompoundField, "type" | "schemaType">>>(displayName: string, fields: SchemaField[], other: Other): (name: string) => CompoundField & {
+    schemaType: SchemaFieldType.Compound;
+    type: FieldType.Compound;
+    collection: Other["collection"];
+};
+export declare function defaultScalarField(field: string, displayName: string): ScalarField & {
+    schemaType: SchemaFieldType.Scalar;
+    type: FieldType.String;
+};
+export declare function defaultCompoundField(field: string, displayName: string, collection: boolean): CompoundField & {
+    type: FieldType.Compound;
+    schemaType: SchemaFieldType.Compound;
+};
+export {};

package/lib/schemaBuilder.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultCompoundField = exports.defaultScalarField = exports.compoundField = exports.boolField = exports.intField = exports.makeCompoundField = exports.makeScalarField = exports.withScalarOptions = exports.stringOptionsField = exports.stringField = exports.buildSchema = void 0;
+const types_1 = require("./types");
+function buildSchema(def) {
+    return Object.entries(def).map((x) => x[1](x[0]));
+}
+exports.buildSchema = buildSchema;
+function stringField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.String, displayName }, options));
+}
+exports.stringField = stringField;
+function stringOptionsField(displayName, ...options) {
+    return makeScalarField({
+        type: types_1.FieldType.String,
+        displayName,
+        restrictions: { options },
+    });
+}
+exports.stringOptionsField = stringOptionsField;
+function withScalarOptions(options, v) {
+    return (n) => (Object.assign(Object.assign({}, v(n)), options));
+}
+exports.withScalarOptions = withScalarOptions;
+function makeScalarField(options) {
+    return (n) => (Object.assign(Object.assign({}, defaultScalarField(n, n)), options));
+}
+exports.makeScalarField = makeScalarField;
+function makeCompoundField(options) {
+    return (n) => (Object.assign(Object.assign({}, defaultCompoundField(n, n, false)), options));
+}
+exports.makeCompoundField = makeCompoundField;
+function intField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.Int, displayName }, options));
+}
+exports.intField = intField;
+function boolField(displayName, options) {
+    return makeScalarField(Object.assign({ type: types_1.FieldType.Bool, displayName }, options));
+}
+exports.boolField = boolField;
+function compoundField(displayName, fields, other) {
+    return (field) => (Object.assign(Object.assign(Object.assign({}, defaultCompoundField(field, displayName, false)), other), { children: fields }));
+}
+exports.compoundField = compoundField;
+function defaultScalarField(field, displayName) {
+    return {
+        restrictions: {
+            options: [],
+        },
+        tags: [],
+        field,
+        displayName,
+        type: types_1.FieldType.String,
+        collection: false,
+        searchable: false,
+        schemaType: types_1.SchemaFieldType.Scalar,
+        system: false,
+        entityRefType: "",
+        parentField: "",
+        required: false,
+        defaultValue: undefined,
+        onlyForTypes: [],
+        isTypeField: false,
+    };
+}
+exports.defaultScalarField = defaultScalarField;
+function defaultCompoundField(field, displayName, collection) {
+    return {
+        tags: [],
+        field,
+        displayName,
+        type: types_1.FieldType.Compound,
+        collection,
+        schemaType: types_1.SchemaFieldType.Compound,
+        system: false,
+        treeChildren: false,
+        children: [],
+        onlyForTypes: [],
+    };
+}
+exports.defaultCompoundField = defaultCompoundField;