art-bd-ui 1.0.44 → 1.0.45

package/dist/cjs/components/forms/dropzone/file-preview.js

@@ -42,11 +42,12 @@ const MediaIconMap = {
     other: { icon: file.default, colorClass: "text-gray-600", bgClass: "bg-gray-100" },
 };
 function FilePreview({ file, className }) {
-    var _a;
+    var _a, _b;
     const mediaType = (file === null || file === void 0 ? void 0 : file.type) ? getMediaType(file.type) : "other";
     const { icon: IconComp, colorClass, bgClass } = MediaIconMap[mediaType];
-    if (mediaType === "image" && (file === null || file === void 0 ? void 0 : file.url)) {
-        return (jsxRuntime.jsx("div", { className: utils.cn("relative flex shrink-0 overflow-hidden rounded-sm w-full h-full", className), children: jsxRuntime.jsx("img", { src: file.url, alt: (_a = file.name) !== null && _a !== void 0 ? _a : "Preview", className: "h-full w-full object-cover" }) }));
+    const previewUrl = (_a = file === null || file === void 0 ? void 0 : file.previewUrl) !== null && _a !== void 0 ? _a : file === null || file === void 0 ? void 0 : file.url;
+    if (mediaType === "image" && previewUrl) {
+        return (jsxRuntime.jsx("div", { className: utils.cn("relative flex shrink-0 overflow-hidden rounded-sm w-full h-full", className), children: jsxRuntime.jsx("img", { src: previewUrl, alt: (_b = file === null || file === void 0 ? void 0 : file.name) !== null && _b !== void 0 ? _b : "Preview", className: "h-full w-full object-cover" }) }));
     }
     return (jsxRuntime.jsx("div", { className: utils.cn("flex shrink-0 items-center justify-center rounded-sm h-full w-full", bgClass, className), children: jsxRuntime.jsx(IconComp, { className: utils.cn("size-4", colorClass) }) }));
 }

package/dist/cjs/components/forms/dynamic-form/capabilities/condition-operator-capabilities.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var fieldCondition = require('../types/field-condition.js');
+
+const CONDITION_OPERATOR_KEYS = fieldCondition.DYNAMIC_FORM_CONDITION_OPERATORS;
+const CONDITION_OPERATORS_BY_VALUE_TYPE = {
+    string: ["eq", "ne", "empty", "notEmpty", "in", "notIn", "contains", "notContains", "startsWith", "endsWith", "regex"],
+    number: ["eq", "ne", "empty", "notEmpty", "in", "notIn", "gt", "gte", "lt", "lte", "between"],
+    boolean: ["eq", "ne"],
+    date: ["eq", "ne", "empty", "notEmpty", "gt", "gte", "lt", "lte", "between"],
+    enum: ["eq", "ne", "empty", "notEmpty", "in", "notIn"],
+    array: ["empty", "notEmpty", "includes", "excludes", "includesAny", "includesAll", "size"],
+    object: ["empty", "notEmpty"],
+};
+const isConditionOperator = (operator) => {
+    return fieldCondition.DYNAMIC_FORM_CONDITION_OPERATORS.includes(operator);
+};
+
+exports.CONDITION_OPERATORS_BY_VALUE_TYPE = CONDITION_OPERATORS_BY_VALUE_TYPE;
+exports.CONDITION_OPERATOR_KEYS = CONDITION_OPERATOR_KEYS;
+exports.isConditionOperator = isConditionOperator;

package/dist/cjs/components/forms/dynamic-form/capabilities/field-type-capabilities.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var conditionOperatorCapabilities = require('./condition-operator-capabilities.js');
+
+const FIELD_VALUE_TYPE_BY_FIELD_TYPE = {
+    text: "string",
+    textarea: "string",
+    richText: "string",
+    email: "string",
+    url: "string",
+    number: "number",
+    select: "enum",
+    multiSelect: "array",
+    tagsInput: "array",
+    countrySelect: "string",
+    currencySelect: "string",
+    phoneInput: "string",
+    checkbox: "boolean",
+    date: "date",
+    dateTime: "date",
+    dateRange: "object",
+    time: "string",
+    month: "number",
+    year: "number",
+    file: "object",
+    hidden: "object",
+};
+const FIELD_TYPE_CAPABILITIES = {
+    text: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    textarea: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    richText: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    email: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    url: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    number: {
+        valueType: "number",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.number,
+    },
+    select: {
+        valueType: "enum",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.enum,
+        requiresOptions: true,
+    },
+    multiSelect: {
+        valueType: "array",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.array,
+        requiresOptions: true,
+    },
+    tagsInput: {
+        valueType: "array",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.array,
+    },
+    countrySelect: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    currencySelect: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    phoneInput: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    checkbox: {
+        valueType: "boolean",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.boolean,
+    },
+    date: {
+        valueType: "date",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.date,
+    },
+    dateTime: {
+        valueType: "date",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.date,
+    },
+    dateRange: {
+        valueType: "object",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.object,
+    },
+    time: {
+        valueType: "string",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.string,
+    },
+    month: {
+        valueType: "number",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.number,
+    },
+    year: {
+        valueType: "number",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.number,
+    },
+    file: {
+        valueType: "object",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.object,
+    },
+    hidden: {
+        valueType: "object",
+        operators: conditionOperatorCapabilities.CONDITION_OPERATORS_BY_VALUE_TYPE.object,
+    },
+};
+
+exports.FIELD_TYPE_CAPABILITIES = FIELD_TYPE_CAPABILITIES;
+exports.FIELD_VALUE_TYPE_BY_FIELD_TYPE = FIELD_VALUE_TYPE_BY_FIELD_TYPE;

package/dist/cjs/components/forms/dynamic-form/conditions/condition-operator-registry.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const isJsonPrimitive = (value) => {
+    return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+};
+const areJsonPrimitivesEqual = (left, right) => {
+    return isJsonPrimitive(left) && isJsonPrimitive(right) && Object.is(left, right);
+};
+const isEmptyValue = (value) => {
+    if (value == null) {
+        return true;
+    }
+    if (typeof value === "string") {
+        return value.trim().length === 0;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === "object") {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+};
+const includesPrimitive = (values, value) => {
+    return Array.isArray(values) && values.some((item) => areJsonPrimitivesEqual(item, value));
+};
+const getComparableValue = (value) => {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (value instanceof Date && Number.isFinite(value.getTime())) {
+        return value.getTime();
+    }
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return undefined;
+    }
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) {
+        return numeric;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+};
+const compare = (actual, expected, predicate) => {
+    const actualValue = getComparableValue(actual);
+    const expectedValue = getComparableValue(expected);
+    return typeof actualValue === "number" && typeof expectedValue === "number" && predicate(actualValue, expectedValue);
+};
+const CONDITION_OPERATOR_REGISTRY = {
+    eq: (actual, expected) => areJsonPrimitivesEqual(actual, expected),
+    ne: (actual, expected) => !areJsonPrimitivesEqual(actual, expected),
+    empty: (actual, expected) => isEmptyValue(actual) === expected,
+    notEmpty: (actual, expected) => !isEmptyValue(actual) === expected,
+    in: (actual, expected) => includesPrimitive(expected, actual),
+    notIn: (actual, expected) => !includesPrimitive(expected, actual),
+    contains: (actual, expected) => typeof actual === "string" && typeof expected === "string" && actual.includes(expected),
+    notContains: (actual, expected) => typeof actual === "string" && typeof expected === "string" && !actual.includes(expected),
+    startsWith: (actual, expected) => typeof actual === "string" && typeof expected === "string" && actual.startsWith(expected),
+    endsWith: (actual, expected) => typeof actual === "string" && typeof expected === "string" && actual.endsWith(expected),
+    regex: (actual, expected) => {
+        if (typeof actual !== "string" || typeof expected !== "string") {
+            return false;
+        }
+        try {
+            return new RegExp(expected).test(actual);
+        }
+        catch (_a) {
+            return false;
+        }
+    },
+    gt: (actual, expected) => compare(actual, expected, (left, right) => left > right),
+    gte: (actual, expected) => compare(actual, expected, (left, right) => left >= right),
+    lt: (actual, expected) => compare(actual, expected, (left, right) => left < right),
+    lte: (actual, expected) => compare(actual, expected, (left, right) => left <= right),
+    between: (actual, expected) => {
+        if (!Array.isArray(expected) || expected.length !== 2) {
+            return false;
+        }
+        const actualValue = getComparableValue(actual);
+        const minValue = getComparableValue(expected[0]);
+        const maxValue = getComparableValue(expected[1]);
+        return (typeof actualValue === "number" &&
+            typeof minValue === "number" &&
+            typeof maxValue === "number" &&
+            actualValue >= minValue &&
+            actualValue <= maxValue);
+    },
+    includes: (actual, expected) => includesPrimitive(actual, expected),
+    excludes: (actual, expected) => Array.isArray(actual) && !includesPrimitive(actual, expected),
+    includesAny: (actual, expected) => Array.isArray(actual) && Array.isArray(expected) && expected.some((item) => includesPrimitive(actual, item)),
+    includesAll: (actual, expected) => Array.isArray(actual) && Array.isArray(expected) && expected.every((item) => includesPrimitive(actual, item)),
+    size: (actual, expected) => Array.isArray(actual) && typeof expected === "number" && actual.length === expected,
+};
+
+exports.CONDITION_OPERATOR_REGISTRY = CONDITION_OPERATOR_REGISTRY;
+exports.areJsonPrimitivesEqual = areJsonPrimitivesEqual;
+exports.isEmptyValue = isEmptyValue;
+exports.isJsonPrimitive = isJsonPrimitive;

package/dist/cjs/components/forms/dynamic-form/conditions/evaluate-field-condition.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var conditionOperatorCapabilities = require('../capabilities/condition-operator-capabilities.js');
+require('../capabilities/field-type-capabilities.js');
+var isPlainRecord = require('../is-plain-record.js');
+var conditionOperatorRegistry = require('./condition-operator-registry.js');
+var conditionOperators = require('../../../ui/condition-builder/condition-operators.js');
+
+const RESERVED_FIELD_KEYS = new Set(conditionOperators.CONDITION_GROUP_OPERATORS);
+const isOperatorExpression = (value) => {
+    return isPlainRecord.isPlainRecord(value) && Object.keys(value).some(conditionOperatorCapabilities.isConditionOperator);
+};
+const getFieldValueByName = (fieldName, context) => {
+    const field = context.fields.find((item) => item.name === fieldName);
+    if (!field) {
+        return { found: false, value: undefined };
+    }
+    return { found: true, value: context.values[field.name] };
+};
+const evaluateFieldValue = (actualValue, expected) => {
+    if (conditionOperatorRegistry.isJsonPrimitive(expected)) {
+        return conditionOperatorRegistry.areJsonPrimitivesEqual(actualValue, expected);
+    }
+    if (!isOperatorExpression(expected)) {
+        return false;
+    }
+    return Object.entries(expected).every(([operator, operatorValue]) => {
+        if (!conditionOperatorCapabilities.isConditionOperator(operator)) {
+            return false;
+        }
+        return conditionOperatorRegistry.CONDITION_OPERATOR_REGISTRY[operator](actualValue, operatorValue);
+    });
+};
+const evaluateConditionFilter = (condition, context) => {
+    if (!isPlainRecord.isPlainRecord(condition)) {
+        return false;
+    }
+    return Object.entries(condition).every(([key, value]) => {
+        if (key === "AND") {
+            return Array.isArray(value) && value.every((item) => evaluateConditionFilter(item, context));
+        }
+        if (key === "OR") {
+            return Array.isArray(value) && value.some((item) => evaluateConditionFilter(item, context));
+        }
+        if (key === "NOT") {
+            return Array.isArray(value) && value.every((item) => !evaluateConditionFilter(item, context));
+        }
+        if (key.startsWith("$") || RESERVED_FIELD_KEYS.has(key)) {
+            return false;
+        }
+        const resolvedField = getFieldValueByName(key, context);
+        return resolvedField.found && evaluateFieldValue(resolvedField.value, value);
+    });
+};
+const evaluateConditionalBoolean = (value, context) => {
+    if (typeof value === "undefined") {
+        return context.defaultValue;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    return evaluateConditionFilter(value, context);
+};
+
+exports.evaluateConditionFilter = evaluateConditionFilter;
+exports.evaluateConditionalBoolean = evaluateConditionalBoolean;

package/dist/cjs/components/forms/dynamic-form/conditions/validate-field-condition.js

@@ -0,0 +1,61 @@
+'use strict';
+
+var conditionOperatorCapabilities = require('../capabilities/condition-operator-capabilities.js');
+var fieldTypeCapabilities = require('../capabilities/field-type-capabilities.js');
+var isPlainRecord = require('../is-plain-record.js');
+var conditionOperatorRegistry = require('./condition-operator-registry.js');
+var conditionOperators = require('../../../ui/condition-builder/condition-operators.js');
+
+const RESERVED_KEYS = new Set(conditionOperators.CONDITION_GROUP_OPERATORS);
+const isOperatorExpression = (value) => {
+    return isPlainRecord.isPlainRecord(value) && Object.keys(value).some(conditionOperatorCapabilities.isConditionOperator);
+};
+const validateConditionFilterValue = (field, value, path) => {
+    const capability = fieldTypeCapabilities.FIELD_TYPE_CAPABILITIES[field.type];
+    if (!capability) {
+        return [`${path}: referenced field "${field.name}" has unsupported type "${field.type}"`];
+    }
+    const operators = capability.operators;
+    if (conditionOperatorRegistry.isJsonPrimitive(value)) {
+        return operators.includes("eq") ? [] : [`${path}: shorthand equality is not allowed for ${field.type} fields`];
+    }
+    if (!isOperatorExpression(value)) {
+        return [`${path}: condition value must be a JSON primitive or operator expression`];
+    }
+    return Object.keys(value).flatMap((operator) => {
+        if (!conditionOperatorCapabilities.isConditionOperator(operator)) {
+            return [`${path}: unsupported condition operator "${operator}"`];
+        }
+        if (!operators.includes(operator)) {
+            return [`${path}: operator "${operator}" is not allowed for ${field.type} fields`];
+        }
+        return [];
+    });
+};
+const validateConditionFilter = (condition, { fields, path = "condition" }) => {
+    if (!isPlainRecord.isPlainRecord(condition)) {
+        return [`${path}: condition must be a plain object`];
+    }
+    const fieldsByName = new Map(fields.map((field) => [field.name, field]));
+    return Object.entries(condition).flatMap(([key, value]) => {
+        if (key === "AND" || key === "OR" || key === "NOT") {
+            if (!Array.isArray(value)) {
+                return [`${path}.${key}: value must be an array of conditions`];
+            }
+            return value.flatMap((item, index) => validateConditionFilter(item, {
+                fields,
+                path: `${path}.${key}[${index}]`,
+            }));
+        }
+        if (key.startsWith("$") || RESERVED_KEYS.has(key)) {
+            return [`${path}: "${key}" is reserved and cannot be used as a field name`];
+        }
+        const field = fieldsByName.get(key);
+        if (!field) {
+            return [`${path}: condition references unknown field name "${key}"`];
+        }
+        return validateConditionFilterValue(field, value, `${path}.${key}`);
+    });
+};
+
+exports.validateConditionFilter = validateConditionFilter;

package/dist/cjs/components/forms/dynamic-form/dynamic-form-field.js

@@ -0,0 +1,20 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var fieldRendererResolver = require('./field-renderer-resolver.js');
+var form = require('../form/form.js');
+require('../../../node_modules/tslib/tslib.es6.js');
+
+const DynamicFormField = ({ field, form: form$1, renderer, disabled }) => {
+    const Renderer = renderer !== null && renderer !== void 0 ? renderer : fieldRendererResolver.resolveDynamicFormFieldRenderer({ field });
+    return (jsxRuntime.jsx(form.FormField, { control: form$1.control, name: field.name, render: ({ field: input }) => {
+            const renderer = jsxRuntime.jsx(Renderer, { field: field, form: form$1, input: input, disabled: disabled });
+            if (field.type === "hidden") {
+                return renderer;
+            }
+            return (jsxRuntime.jsxs(form.FormItem, { children: [field.label ? jsxRuntime.jsx(form.FormLabel, { children: field.label }) : null, jsxRuntime.jsx(form.FormFieldControl, { children: renderer }), field.description ? jsxRuntime.jsx(form.FormDescription, { children: field.description }) : null, jsxRuntime.jsx(form.FormMessage, {})] }));
+        } }));
+};
+
+exports.DynamicFormField = DynamicFormField;

package/dist/cjs/components/forms/dynamic-form/dynamic-form.js

@@ -0,0 +1,61 @@
+"use client";
+'use strict';
+
+var tslib_es6 = require('../../../node_modules/tslib/tslib.es6.js');
+var jsxRuntime = require('react/jsx-runtime');
+var zod = require('../../../node_modules/@hookform/resolvers/zod/dist/zod.js');
+var React = require('react');
+var index_esm = require('../../../node_modules/react-hook-form/dist/index.esm.js');
+var dynamicFormFieldRenderer = require('./layout/dynamic-form-field-renderer.js');
+var dynamicFormGridLayoutRenderer = require('./layout/dynamic-form-grid-layout-renderer.js');
+var dynamicFormLayoutRenderer = require('./layout/dynamic-form-layout-renderer.js');
+var utils = require('./utils.js');
+var form = require('../form/form.js');
+
+const DynamicFormComponent = (_a, ref) => {
+    var { definition, validationSchema, initialValues, onSubmit, fieldRendererOverrides, layoutRenderer, onReset } = _a, formProps = tslib_es6.__rest(_a, ["definition", "validationSchema", "initialValues", "onSubmit", "fieldRendererOverrides", "layoutRenderer", "onReset"]);
+    const zodSchema = React.useMemo(() => {
+        return validationSchema !== null && validationSchema !== void 0 ? validationSchema : utils.buildZodSchema(definition);
+    }, [definition, validationSchema]);
+    const formInitialValues = React.useMemo(() => utils.buildInitialValues(definition, initialValues), [definition, initialValues]);
+    const form$1 = index_esm.useForm({
+        resolver: zod.zodResolver(zodSchema, undefined, { raw: true }),
+        defaultValues: formInitialValues,
+    });
+    const values = form$1.watch();
+    const fieldRenderer = dynamicFormFieldRenderer.useDynamicFormFieldRenderer({
+        definition,
+        fieldRendererOverrides,
+        form: form$1,
+        values,
+    });
+    const ResolvedLayoutRenderer = layoutRenderer !== null && layoutRenderer !== void 0 ? layoutRenderer : (definition.layout ? dynamicFormGridLayoutRenderer.DynamicFormGridLayoutRenderer : dynamicFormLayoutRenderer.DynamicFormDefaultLayoutRenderer);
+    const getValues = React.useCallback(() => {
+        return form$1.getValues();
+    }, [form$1]);
+    const handleSubmit = React.useCallback((nextValues, event) => {
+        return onSubmit(nextValues, event);
+    }, [onSubmit]);
+    const submit = React.useCallback(() => {
+        return form$1.handleSubmit(handleSubmit)();
+    }, [form$1, handleSubmit]);
+    const reset = React.useCallback(() => {
+        form$1.reset(formInitialValues);
+    }, [form$1, formInitialValues]);
+    const handleReset = React.useCallback((event) => {
+        onReset === null || onReset === void 0 ? void 0 : onReset(event);
+        if (!event.defaultPrevented) {
+            reset();
+        }
+    }, [onReset, reset]);
+    React.useImperativeHandle(ref, () => ({
+        submit,
+        reset,
+        getValues,
+        getState: () => form$1.formState,
+    }), [form$1.formState, getValues, reset, submit]);
+    return (jsxRuntime.jsx(form.Form, Object.assign({}, form$1, { children: jsxRuntime.jsx("form", Object.assign({}, formProps, { onReset: handleReset, onSubmit: form$1.handleSubmit(handleSubmit), children: jsxRuntime.jsxs(dynamicFormFieldRenderer.DynamicFormFieldRendererProvider, { value: fieldRenderer, children: [fieldRenderer.renderHiddenFields(), jsxRuntime.jsx(ResolvedLayoutRenderer, { definition: definition, fields: fieldRenderer.fields, fieldNames: fieldRenderer.fieldNames, Slot: dynamicFormFieldRenderer.FormFieldSlot })] }) })) })));
+};
+const DynamicForm = React.forwardRef(DynamicFormComponent);
+
+exports.DynamicForm = DynamicForm;

package/dist/cjs/components/forms/dynamic-form/field-renderer-registry.js

@@ -0,0 +1,48 @@
+"use client";
+'use strict';
+
+var checkboxFieldRenderer = require('./renderers/checkbox-field-renderer.js');
+var countrySelectFieldRenderer = require('./renderers/country-select-field-renderer.js');
+var currencySelectFieldRenderer = require('./renderers/currency-select-field-renderer.js');
+var dateFieldRenderer = require('./renderers/date-field-renderer.js');
+var dateRangeFieldRenderer = require('./renderers/date-range-field-renderer.js');
+var dateTimeFieldRenderer = require('./renderers/date-time-field-renderer.js');
+var fileFieldRenderer = require('./renderers/file-field-renderer.js');
+var hiddenFieldRenderer = require('./renderers/hidden-field-renderer.js');
+var monthFieldRenderer = require('./renderers/month-field-renderer.js');
+var multiSelectFieldRenderer = require('./renderers/multi-select-field-renderer.js');
+var numberFieldRenderer = require('./renderers/number-field-renderer.js');
+var phoneInputFieldRenderer = require('./renderers/phone-input-field-renderer.js');
+var richTextFieldRenderer = require('./renderers/rich-text-field-renderer.js');
+var selectFieldRenderer = require('./renderers/select-field-renderer.js');
+var tagsInputFieldRenderer = require('./renderers/tags-input-field-renderer.js');
+var textFieldRenderer = require('./renderers/text-field-renderer.js');
+var textareaFieldRenderer = require('./renderers/textarea-field-renderer.js');
+var timeFieldRenderer = require('./renderers/time-field-renderer.js');
+var yearFieldRenderer = require('./renderers/year-field-renderer.js');
+
+const FIELD_RENDERER_REGISTRY = {
+    text: textFieldRenderer.TextFieldRenderer,
+    textarea: textareaFieldRenderer.TextareaFieldRenderer,
+    richText: richTextFieldRenderer.RichTextFieldRenderer,
+    email: textFieldRenderer.TextFieldRenderer,
+    url: textFieldRenderer.TextFieldRenderer,
+    number: numberFieldRenderer.NumberFieldRenderer,
+    select: selectFieldRenderer.SelectFieldRenderer,
+    multiSelect: multiSelectFieldRenderer.MultiSelectFieldRenderer,
+    tagsInput: tagsInputFieldRenderer.TagsInputFieldRenderer,
+    countrySelect: countrySelectFieldRenderer.CountrySelectFieldRenderer,
+    currencySelect: currencySelectFieldRenderer.CurrencySelectFieldRenderer,
+    phoneInput: phoneInputFieldRenderer.PhoneInputFieldRenderer,
+    checkbox: checkboxFieldRenderer.CheckboxFieldRenderer,
+    date: dateFieldRenderer.DateFieldRenderer,
+    dateTime: dateTimeFieldRenderer.DateTimeFieldRenderer,
+    dateRange: dateRangeFieldRenderer.DateRangeFieldRenderer,
+    time: timeFieldRenderer.TimeFieldRenderer,
+    month: monthFieldRenderer.MonthFieldRenderer,
+    year: yearFieldRenderer.YearFieldRenderer,
+    file: fileFieldRenderer.FileFieldRenderer,
+    hidden: hiddenFieldRenderer.HiddenFieldRenderer,
+};
+
+exports.FIELD_RENDERER_REGISTRY = FIELD_RENDERER_REGISTRY;

package/dist/cjs/components/forms/dynamic-form/field-renderer-resolver.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var fieldRendererRegistry = require('./field-renderer-registry.js');
+
+const resolveDynamicFormFieldRenderer = ({ field, fieldRendererOverrides, }) => {
+    var _a, _b, _c, _d;
+    if (field.type === "hidden") {
+        return fieldRendererRegistry.FIELD_RENDERER_REGISTRY.hidden;
+    }
+    return ((_d = (_b = (_a = fieldRendererOverrides === null || fieldRendererOverrides === void 0 ? void 0 : fieldRendererOverrides.byName) === null || _a === void 0 ? void 0 : _a[field.name]) !== null && _b !== void 0 ? _b : (_c = fieldRendererOverrides === null || fieldRendererOverrides === void 0 ? void 0 : fieldRendererOverrides.byType) === null || _c === void 0 ? void 0 : _c[field.type]) !== null && _d !== void 0 ? _d : fieldRendererRegistry.FIELD_RENDERER_REGISTRY[field.type]);
+};
+
+exports.resolveDynamicFormFieldRenderer = resolveDynamicFormFieldRenderer;

package/dist/cjs/components/forms/dynamic-form/is-plain-record.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var isPlainObject = require('../../../_virtual/isPlainObject.js');
+
+const isPlainRecord = (value) => {
+    return isPlainObject.default(value);
+};
+
+exports.isPlainRecord = isPlainRecord;

package/dist/cjs/components/forms/dynamic-form/layout/dynamic-form-field-renderer.js

@@ -0,0 +1,116 @@
+"use client";
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var dynamicFormField = require('../dynamic-form-field.js');
+var fieldRendererResolver = require('../field-renderer-resolver.js');
+var evaluateFieldCondition = require('../conditions/evaluate-field-condition.js');
+require('../conditions/validate-field-condition.js');
+
+const DynamicFormFieldRendererContext = React.createContext(null);
+const isFieldVisible = (field, { definition, values }) => {
+    return evaluateFieldCondition.evaluateConditionalBoolean(field.visible, {
+        fields: definition.fields,
+        values,
+        defaultValue: true,
+    });
+};
+const renderDynamicFormField = (field, { definition, fieldRendererOverrides, form, values }) => {
+    const visible = isFieldVisible(field, { definition, values });
+    if (!visible) {
+        return null;
+    }
+    const disabled = evaluateFieldCondition.evaluateConditionalBoolean(field.disabled, {
+        fields: definition.fields,
+        values,
+        defaultValue: false,
+    });
+    const renderer = fieldRendererResolver.resolveDynamicFormFieldRenderer({ field, fieldRendererOverrides });
+    return jsxRuntime.jsx(dynamicFormField.DynamicFormField, { field: field, form: form, renderer: renderer, disabled: disabled }, field.name);
+};
+const useDynamicFormFieldRenderer = ({ definition, fieldRendererOverrides, form, values, }) => {
+    const context = React.useMemo(() => ({ definition, fieldRendererOverrides, form, values }), [definition, fieldRendererOverrides, form, values]);
+    const fieldsByName = React.useMemo(() => {
+        return new Map(definition.fields.map((field) => [field.name, field]));
+    }, [definition.fields]);
+    const warnedUnknownFieldsRef = React.useRef(new Set());
+    const layoutFields = React.useMemo(() => {
+        return definition.fields
+            .map((field) => {
+            const hidden = field.type === "hidden" || !isFieldVisible(field, context);
+            return {
+                name: field.name,
+                label: field.label,
+                hidden,
+            };
+        })
+            .filter((field) => !field.hidden);
+    }, [context, definition.fields]);
+    const fieldNames = React.useMemo(() => layoutFields.map((field) => field.name), [layoutFields]);
+    const hasField = React.useCallback((name) => fieldsByName.has(name), [fieldsByName]);
+    const renderField = React.useCallback((name) => {
+        const field = fieldsByName.get(name);
+        if (!field) {
+            return null;
+        }
+        return renderDynamicFormField(field, context);
+    }, [context, fieldsByName]);
+    const renderHiddenFields = React.useCallback(() => {
+        return definition.fields
+            .filter((field) => field.type === "hidden")
+            .map((field) => renderDynamicFormField(field, context));
+    }, [context, definition.fields]);
+    return {
+        fields: layoutFields,
+        fieldNames,
+        definition,
+        hasField,
+        renderField,
+        renderHiddenFields,
+        warnedUnknownFieldsRef,
+    };
+};
+const DynamicFormFieldRendererProvider = ({ value, children }) => {
+    return jsxRuntime.jsx(DynamicFormFieldRendererContext.Provider, { value: value, children: children });
+};
+const useDynamicFormFieldRendererContext = () => {
+    const context = React.useContext(DynamicFormFieldRendererContext);
+    if (!context) {
+        throw new Error("FormFieldSlot must be rendered inside a DynamicForm layout renderer");
+    }
+    return context;
+};
+const FormFieldSlot = ({ name, className, fallback = null }) => {
+    const fieldRenderer = useDynamicFormFieldRendererContext();
+    const fieldExists = fieldRenderer.hasField(name);
+    React.useEffect(() => {
+        if (process.env.NODE_ENV === "production") {
+            return;
+        }
+        if (!fieldExists) {
+            if (!fieldRenderer.warnedUnknownFieldsRef.current.has(name)) {
+                fieldRenderer.warnedUnknownFieldsRef.current.add(name);
+                console.warn(`DynamicForm field slot references unknown field name "${name}"`);
+            }
+            return;
+        }
+    }, [fieldExists, fieldRenderer, name]);
+    if (!fieldExists) {
+        return fallback;
+    }
+    const renderedField = fieldRenderer.renderField(name);
+    if (!renderedField) {
+        return null;
+    }
+    if (className) {
+        return jsxRuntime.jsx("div", { className: className, children: renderedField });
+    }
+    return renderedField;
+};
+
+exports.DynamicFormFieldRendererProvider = DynamicFormFieldRendererProvider;
+exports.FormFieldSlot = FormFieldSlot;
+exports.renderDynamicFormField = renderDynamicFormField;
+exports.useDynamicFormFieldRenderer = useDynamicFormFieldRenderer;
+exports.useDynamicFormFieldRendererContext = useDynamicFormFieldRendererContext;