@uipath/apollo-wind 2.60.1 → 2.62.0

package/dist/components/forms/schema-serializer.cjs

@@ -182,6 +182,14 @@ function serializeField(field) {
     if (field.ariaDescribedBy) result.ariaDescribedBy = field.ariaDescribedBy;
     if (field.tooltip) result.tooltip = field.tooltip;
     if (field.tooltipAriaLabel) result.tooltipAriaLabel = field.tooltipAriaLabel;
+    if (field.valueModes) result.valueModes = field.valueModes;
+    if (field.headerActions) result.headerActions = [
+        ...field.headerActions
+    ];
+    if (field.menuActions) result.menuActions = [
+        ...field.menuActions
+    ];
+    if (field.badge) result.badge = field.badge;
     if ('options' in field && field.options) result.options = serializeOptions(field.options);
     if ('rows' in field && field.rows) result.rows = field.rows;
     if ('min' in field && void 0 !== field.min) result.min = field.min;

package/dist/components/forms/schema-serializer.js

@@ -153,6 +153,14 @@ function serializeField(field) {
     if (field.ariaDescribedBy) result.ariaDescribedBy = field.ariaDescribedBy;
     if (field.tooltip) result.tooltip = field.tooltip;
     if (field.tooltipAriaLabel) result.tooltipAriaLabel = field.tooltipAriaLabel;
+    if (field.valueModes) result.valueModes = field.valueModes;
+    if (field.headerActions) result.headerActions = [
+        ...field.headerActions
+    ];
+    if (field.menuActions) result.menuActions = [
+        ...field.menuActions
+    ];
+    if (field.badge) result.badge = field.badge;
     if ('options' in field && field.options) result.options = serializeOptions(field.options);
     if ('rows' in field && field.rows) result.rows = field.rows;
     if ('min' in field && void 0 !== field.min) result.min = field.min;

package/dist/components/forms/string-list-field.cjs

@@ -24,6 +24,7 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    StringListControl: ()=>StringListControl,
     formatTemplate: ()=>formatTemplate,
     StringListField: ()=>StringListField
 });
@@ -37,6 +38,35 @@ function formatTemplate(template, values) {
     return template.replace(/\{\{(\w+)\}\}/g, (match, token)=>token in values ? String(values[token]) : match);
 }
 function StringListField({ field, value, onChange, onBlur, error, disabled = false, required = false, inputRef }) {
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(form_field_cjs_namespaceObject.FormField, {
+        "data-slot": "string-list-field",
+        children: [
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldLabel, {
+                required: required,
+                tooltip: field.tooltip,
+                tooltipAriaLabel: field.tooltipAriaLabel,
+                children: field.label
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(StringListControl, {
+                field: field,
+                value: value,
+                onChange: onChange,
+                onBlur: onBlur,
+                invalid: !!error,
+                disabled: disabled,
+                inputRef: inputRef
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldDescription, {
+                children: field.description
+            }),
+            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldError, {
+                id: `${field.name}-error`,
+                children: error
+            })
+        ]
+    });
+}
+function StringListControl({ field, value, onChange, onBlur, invalid = false, disabled = false, inputRef }) {
     const items = value ?? [];
     const maxItems = field.maxItems ?? 1 / 0;
     const canAdd = !disabled && items.length < maxItems;
@@ -79,15 +109,8 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
         items,
         onChange
     ]);
-    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(form_field_cjs_namespaceObject.FormField, {
-        "data-slot": "string-list-field",
+    return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
         children: [
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldLabel, {
-                required: required,
-                tooltip: field.tooltip,
-                tooltipAriaLabel: field.tooltipAriaLabel,
-                children: field.label
-            }),
             /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)("div", {
                 className: "grid gap-1.5",
                 children: items.map((item, index)=>/*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)("div", {
@@ -102,9 +125,9 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
                                 maxLength: field.maxLength,
                                 disabled: disabled,
                                 "aria-label": `${field.label} ${index + 1}`,
-                                "aria-invalid": error ? true : void 0,
-                                "aria-describedby": error ? `${field.name}-error` : void 0,
-                                "aria-errormessage": error ? `${field.name}-error` : void 0,
+                                "aria-invalid": invalid || void 0,
+                                "aria-describedby": invalid ? `${field.name}-error` : void 0,
+                                "aria-errormessage": invalid ? `${field.name}-error` : void 0,
                                 className: "flex-1"
                             }),
                             /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(button_cjs_namespaceObject.Button, {
@@ -135,20 +158,15 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
                         addItemLabel
                     ]
                 })
-            }),
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldDescription, {
-                children: field.description
-            }),
-            /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(form_field_cjs_namespaceObject.FormFieldError, {
-                id: `${field.name}-error`,
-                children: error
             })
         ]
     });
 }
+exports.StringListControl = __webpack_exports__.StringListControl;
 exports.StringListField = __webpack_exports__.StringListField;
 exports.formatTemplate = __webpack_exports__.formatTemplate;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "StringListControl",
     "StringListField",
     "formatTemplate"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/components/forms/string-list-field.d.ts

@@ -27,3 +27,9 @@ export interface StringListFieldProps {
  * is handled for you — it mounts a provider for schemas that use tooltip metadata.
  */
 export declare function StringListField({ field, value, onChange, onBlur, error, disabled, required, inputRef, }: StringListFieldProps): import("react/jsx-runtime").JSX.Element;
+export interface StringListControlProps extends Omit<StringListFieldProps, 'error' | 'required'> {
+    /** Marks every row invalid and points it at the `${field.name}-error` message. */
+    invalid?: boolean;
+}
+/** The rows and Add button of a string list, without its label, description or error. */
+export declare function StringListControl({ field, value, onChange, onBlur, invalid, disabled, inputRef, }: StringListControlProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/forms/string-list-field.js

@@ -1,4 +1,4 @@
-import { jsx, jsxs } from "react/jsx-runtime";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { Plus, Trash2 } from "lucide-react";
 import { useCallback, useState } from "react";
 import { Button } from "../ui/button.js";
@@ -8,6 +8,35 @@ function formatTemplate(template, values) {
     return template.replace(/\{\{(\w+)\}\}/g, (match, token)=>token in values ? String(values[token]) : match);
 }
 function StringListField({ field, value, onChange, onBlur, error, disabled = false, required = false, inputRef }) {
+    return /*#__PURE__*/ jsxs(FormField, {
+        "data-slot": "string-list-field",
+        children: [
+            /*#__PURE__*/ jsx(FormFieldLabel, {
+                required: required,
+                tooltip: field.tooltip,
+                tooltipAriaLabel: field.tooltipAriaLabel,
+                children: field.label
+            }),
+            /*#__PURE__*/ jsx(StringListControl, {
+                field: field,
+                value: value,
+                onChange: onChange,
+                onBlur: onBlur,
+                invalid: !!error,
+                disabled: disabled,
+                inputRef: inputRef
+            }),
+            /*#__PURE__*/ jsx(FormFieldDescription, {
+                children: field.description
+            }),
+            /*#__PURE__*/ jsx(FormFieldError, {
+                id: `${field.name}-error`,
+                children: error
+            })
+        ]
+    });
+}
+function StringListControl({ field, value, onChange, onBlur, invalid = false, disabled = false, inputRef }) {
     const items = value ?? [];
     const maxItems = field.maxItems ?? 1 / 0;
     const canAdd = !disabled && items.length < maxItems;
@@ -50,15 +79,8 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
         items,
         onChange
     ]);
-    return /*#__PURE__*/ jsxs(FormField, {
-        "data-slot": "string-list-field",
+    return /*#__PURE__*/ jsxs(Fragment, {
         children: [
-            /*#__PURE__*/ jsx(FormFieldLabel, {
-                required: required,
-                tooltip: field.tooltip,
-                tooltipAriaLabel: field.tooltipAriaLabel,
-                children: field.label
-            }),
             /*#__PURE__*/ jsx("div", {
                 className: "grid gap-1.5",
                 children: items.map((item, index)=>/*#__PURE__*/ jsxs("div", {
@@ -73,9 +95,9 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
                                 maxLength: field.maxLength,
                                 disabled: disabled,
                                 "aria-label": `${field.label} ${index + 1}`,
-                                "aria-invalid": error ? true : void 0,
-                                "aria-describedby": error ? `${field.name}-error` : void 0,
-                                "aria-errormessage": error ? `${field.name}-error` : void 0,
+                                "aria-invalid": invalid || void 0,
+                                "aria-describedby": invalid ? `${field.name}-error` : void 0,
+                                "aria-errormessage": invalid ? `${field.name}-error` : void 0,
                                 className: "flex-1"
                             }),
                             /*#__PURE__*/ jsx(Button, {
@@ -106,15 +128,8 @@ function StringListField({ field, value, onChange, onBlur, error, disabled = fal
                         addItemLabel
                     ]
                 })
-            }),
-            /*#__PURE__*/ jsx(FormFieldDescription, {
-                children: field.description
-            }),
-            /*#__PURE__*/ jsx(FormFieldError, {
-                id: `${field.name}-error`,
-                children: error
             })
         ]
     });
 }
-export { StringListField, formatTemplate };
+export { StringListControl, StringListField, formatTemplate };

package/dist/components/forms/validation-converter.cjs

@@ -27,13 +27,15 @@ __webpack_require__.d(__webpack_exports__, {
     mergeValidationConfigs: ()=>mergeValidationConfigs,
     buildZodSchemaFromFields: ()=>buildZodSchemaFromFields,
     isEmptyFieldValue: ()=>isEmptyFieldValue,
+    modeAwareSchema: ()=>modeAwareSchema,
     validationConfigToZod: ()=>validationConfigToZod
 });
 const external_zod_namespaceObject = require("zod");
+const external_value_modes_cjs_namespaceObject = require("./value-modes.cjs");
 const external_rules_engine_cjs_namespaceObject = require("./rules-engine.cjs");
 function validationConfigToZod(config, fieldType, customValueType) {
     let schema = getBaseSchemaForType(fieldType, customValueType);
-    if (!config) return schema.optional();
+    if (!config) return schema.nullish();
     schema = applyStringConstraints(schema, config, fieldType, customValueType);
     schema = applyNumberConstraints(schema, config, fieldType, customValueType);
     schema = applyArrayConstraints(schema, config, fieldType, customValueType);
@@ -45,7 +47,32 @@ function validationConfigToZod(config, fieldType, customValueType) {
         if (isArrayType(fieldType, customValueType) && (null == config.minItems || config.minItems < 1)) schema = schema.min(1, requiredMessage);
         return applyCustomExpression(schema, config);
     }
-    return applyCustomExpression(schema, config).optional();
+    return applyCustomExpression(schema, config).nullish();
+}
+function modeAwareSchema(literalSchema, { codec, context, required, requiredMessage, validators }) {
+    return external_zod_namespaceObject.z.any().superRefine((stored, ctx)=>{
+        const decoded = codec.decode(stored, context);
+        const empty = (0, external_value_modes_cjs_namespaceObject.isDecodedEmpty)(codec, decoded, context);
+        if (empty && required) return void ctx.addIssue({
+            code: 'custom',
+            message: requiredMessage || 'This field is required'
+        });
+        if (empty) return;
+        if ('literal' === decoded.mode) {
+            const result = literalSchema.safeParse(decoded.value);
+            if (!result.success) for (const issue of result.error.issues)ctx.addIssue({
+                code: 'custom',
+                message: issue.message,
+                path: issue.path
+            });
+            return;
+        }
+        const message = validators?.[decoded.mode]?.(decoded.value, context);
+        if (message) ctx.addIssue({
+            code: 'custom',
+            message
+        });
+    });
 }
 function applyCustomExpression(schema, config) {
     if (!config.custom) return schema;
@@ -74,6 +101,7 @@ function getBaseSchemaForType(fieldType, customValueType) {
             return external_zod_namespaceObject.z.coerce.number();
         case 'checkbox':
         case 'switch':
+        case 'boolean':
             return external_zod_namespaceObject.z.boolean();
         case 'select':
         case 'radio':
@@ -187,11 +215,13 @@ function mergeValidationConfigs(base, override) {
 exports.buildZodSchemaFromFields = __webpack_exports__.buildZodSchemaFromFields;
 exports.isEmptyFieldValue = __webpack_exports__.isEmptyFieldValue;
 exports.mergeValidationConfigs = __webpack_exports__.mergeValidationConfigs;
+exports.modeAwareSchema = __webpack_exports__.modeAwareSchema;
 exports.validationConfigToZod = __webpack_exports__.validationConfigToZod;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildZodSchemaFromFields",
     "isEmptyFieldValue",
     "mergeValidationConfigs",
+    "modeAwareSchema",
     "validationConfigToZod"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/components/forms/validation-converter.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
-import type { CustomValueType, FieldType, ValidationConfig } from './form-schema';
+import type { CustomValueType, FieldType, ValidationConfig, ValueModeId } from './form-schema';
+import { type CodecContext, type ValueModeCodec } from './value-modes';
 export type { CustomValueType };
 /**
  * Validation Converter
@@ -27,6 +28,21 @@ export declare function validationConfigToZod(config: ValidationConfig | undefin
  * `z.any()`, where `required` and the array constraints are no-ops.
  */
 customValueType?: CustomValueType): z.ZodTypeAny;
+export interface ModeAwareSchemaOptions {
+    codec: ValueModeCodec;
+    context: CodecContext;
+    /** Whether the value, in any mode, must be non-empty. */
+    required: boolean;
+    requiredMessage?: string;
+    /** Validation per mode other than `literal`, from `ValueModeDefinition.validate`. */
+    validators?: Partial<Record<ValueModeId, ModeValidator>>;
+}
+export type ModeValidator = (value: unknown, ctx: CodecContext) => string | undefined;
+/**
+ * Validation for a field with value modes. A `literal` value is decoded and validated by the
+ * field type's own schema; a value in any other mode is checked for `required` and by its mode.
+ */
+export declare function modeAwareSchema(literalSchema: z.ZodTypeAny, { codec, context, required, requiredMessage, validators }: ModeAwareSchemaOptions): z.ZodTypeAny;
 /**
  * Check if field type uses string schema
  */

package/dist/components/forms/validation-converter.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
+import { isDecodedEmpty } from "./value-modes.js";
 import { RulesEngine } from "./rules-engine.js";
 function validationConfigToZod(config, fieldType, customValueType) {
     let schema = getBaseSchemaForType(fieldType, customValueType);
-    if (!config) return schema.optional();
+    if (!config) return schema.nullish();
     schema = applyStringConstraints(schema, config, fieldType, customValueType);
     schema = applyNumberConstraints(schema, config, fieldType, customValueType);
     schema = applyArrayConstraints(schema, config, fieldType, customValueType);
@@ -14,7 +15,32 @@ function validationConfigToZod(config, fieldType, customValueType) {
         if (isArrayType(fieldType, customValueType) && (null == config.minItems || config.minItems < 1)) schema = schema.min(1, requiredMessage);
         return applyCustomExpression(schema, config);
     }
-    return applyCustomExpression(schema, config).optional();
+    return applyCustomExpression(schema, config).nullish();
+}
+function modeAwareSchema(literalSchema, { codec, context, required, requiredMessage, validators }) {
+    return z.any().superRefine((stored, ctx)=>{
+        const decoded = codec.decode(stored, context);
+        const empty = isDecodedEmpty(codec, decoded, context);
+        if (empty && required) return void ctx.addIssue({
+            code: 'custom',
+            message: requiredMessage || 'This field is required'
+        });
+        if (empty) return;
+        if ('literal' === decoded.mode) {
+            const result = literalSchema.safeParse(decoded.value);
+            if (!result.success) for (const issue of result.error.issues)ctx.addIssue({
+                code: 'custom',
+                message: issue.message,
+                path: issue.path
+            });
+            return;
+        }
+        const message = validators?.[decoded.mode]?.(decoded.value, context);
+        if (message) ctx.addIssue({
+            code: 'custom',
+            message
+        });
+    });
 }
 function applyCustomExpression(schema, config) {
     if (!config.custom) return schema;
@@ -43,6 +69,7 @@ function getBaseSchemaForType(fieldType, customValueType) {
             return z.coerce.number();
         case 'checkbox':
         case 'switch':
+        case 'boolean':
             return z.boolean();
         case 'select':
         case 'radio':
@@ -153,4 +180,4 @@ function mergeValidationConfigs(base, override) {
         }
     };
 }
-export { buildZodSchemaFromFields, isEmptyFieldValue, mergeValidationConfigs, validationConfigToZod };
+export { buildZodSchemaFromFields, isEmptyFieldValue, mergeValidationConfigs, modeAwareSchema, validationConfigToZod };

package/dist/components/forms/value-modes.cjs

@@ -0,0 +1,253 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    resolveModeOptions: ()=>resolveModeOptions,
+    isValueModeEnvelope: ()=>isValueModeEnvelope,
+    codecContext: ()=>codecContext,
+    literalValueOf: ()=>literalValueOf,
+    convertValue: ()=>convertValue,
+    isDecodedEmpty: ()=>isDecodedEmpty,
+    DEFAULT_VALUE_MODE_REGISTRY: ()=>DEFAULT_VALUE_MODE_REGISTRY,
+    buildValueModeRegistry: ()=>buildValueModeRegistry,
+    VALUE_MODE_OPAQUE: ()=>external_opaque_value_cjs_namespaceObject.VALUE_MODE_OPAQUE,
+    isFieldControlRegistration: ()=>isFieldControlRegistration,
+    envelopeCodec: ()=>envelopeCodec,
+    isEmptyModeValue: ()=>isEmptyModeValue,
+    literalValues: ()=>literalValues,
+    resolveCodec: ()=>resolveCodec
+});
+const built_in_value_modes_cjs_namespaceObject = require("../ui/field-addons/built-in-value-modes.cjs");
+const index_cjs_namespaceObject = require("../../lib/index.cjs");
+const external_opaque_value_cjs_namespaceObject = require("./opaque-value.cjs");
+const external_validation_converter_cjs_namespaceObject = require("./validation-converter.cjs");
+function isValueModeEnvelope(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value) && 'string' == typeof value.$mode;
+}
+const envelopeCodec = {
+    decode (stored) {
+        if (isValueModeEnvelope(stored)) return {
+            mode: stored.$mode,
+            value: stored.value
+        };
+        return {
+            mode: 'literal',
+            value: stored
+        };
+    },
+    encode (mode, inner) {
+        return isCleared(inner) ? {
+            $mode: mode
+        } : {
+            $mode: mode,
+            value: inner
+        };
+    },
+    isEmpty (decoded) {
+        return (0, external_validation_converter_cjs_namespaceObject.isEmptyFieldValue)(decoded.value) || Number.isNaN(decoded.value);
+    }
+};
+function isCleared(value) {
+    return null == value || '' === value || Number.isNaN(value) || Array.isArray(value) && 0 === value.length;
+}
+function isDecodedEmpty(codec, decoded, ctx) {
+    return decoded.empty ?? codec.isEmpty?.(decoded, ctx) ?? (0, external_validation_converter_cjs_namespaceObject.isEmptyFieldValue)(decoded.value);
+}
+function convertValue(codec, from, to, ctx) {
+    const empty = isDecodedEmpty(codec, from, ctx);
+    const result = codec.convert?.({
+        ...from,
+        empty
+    }, to, ctx);
+    if (empty) return {
+        kind: 'ok',
+        value: result?.value
+    };
+    return result ?? {
+        kind: 'lossy',
+        value: void 0
+    };
+}
+function codecContext(field, config) {
+    return {
+        field,
+        fieldType: field.type,
+        valueType: 'custom' === field.type ? field.valueType : void 0,
+        expectedType: expectedType(field, config),
+        config
+    };
+}
+function isFieldControlRegistration(entry) {
+    return 'object' == typeof entry && null !== entry && 'component' in entry;
+}
+const DEFAULT_VALUE_MODE_REGISTRY = Object.freeze({
+    codecs: Object.freeze({}),
+    definitions: Object.freeze({}),
+    controlRegistry: Object.freeze({}),
+    literalControls: Object.freeze({})
+});
+function buildValueModeRegistry(plugins) {
+    const registry = {
+        codecs: {},
+        definitions: {},
+        controlRegistry: {},
+        literalControls: {}
+    };
+    for (const { valueModes } of plugins)if (valueModes) {
+        Object.assign(registry.codecs, valueModes.codecs);
+        for (const [id, definition] of Object.entries(valueModes.definitions ?? {}))registry.definitions[id] = {
+            ...registry.definitions[id],
+            ...definition
+        };
+        Object.assign(registry.controlRegistry, valueModes.controlRegistry);
+        Object.assign(registry.literalControls, valueModes.literalControls);
+    }
+    return registry;
+}
+function resolveCodec(codecs, config) {
+    return codecs[config.codec ?? 'default'] ?? envelopeCodec;
+}
+function expectedType(field, config) {
+    if (config?.expectedType) return config.expectedType;
+    if ('number' === field.type) return 'number';
+    if ('switch' === field.type || 'checkbox' === field.type || 'boolean' === field.type) return 'boolean';
+    if ('custom' === field.type) return field.valueType;
+}
+function resolveModeOptions(field, config, registry, strings = {}) {
+    const builtIns = (0, built_in_value_modes_cjs_namespaceObject.builtInValueModes)(strings, {
+        expectedType: expectedType(field, config)
+    });
+    const options = [];
+    for (const id of config.modes){
+        const definition = registry.definitions[id];
+        const label = config.labels?.[id];
+        const base = (0, built_in_value_modes_cjs_namespaceObject.isBuiltInValueMode)(id) ? builtIns[id] : {};
+        const title = 'function' == typeof definition?.title ? definition.title({
+            field
+        }) : definition?.title;
+        const option = {
+            ...base,
+            id,
+            ...void 0 !== title && {
+                title
+            },
+            ...definition?.description !== void 0 && {
+                description: definition.description
+            },
+            ...definition?.icon && {
+                icon: definition.icon
+            }
+        };
+        if (option.title && option.icon) options.push({
+            ...option,
+            title: label?.title ?? option.title,
+            icon: option.icon,
+            description: label?.description ?? option.description
+        });
+    }
+    return options;
+}
+function isEmptyModeValue(stored, field, codecs = {}) {
+    if (!field.valueModes) return (0, external_validation_converter_cjs_namespaceObject.isEmptyFieldValue)(stored);
+    const codec = resolveCodec(codecs, field.valueModes);
+    const ctx = codecContext(field, field.valueModes);
+    return isDecodedEmpty(codec, codec.decode(stored, ctx), ctx);
+}
+function literalValues(values, schema, codecs = {}) {
+    let result = values;
+    for (const field of modeFields(schema)){
+        const stored = (0, index_cjs_namespaceObject.get)(values, field.name);
+        const read = readLiteral(stored, field, codecs);
+        if (read !== stored) result = withPath(result, field.name.split('.'), read);
+    }
+    return result;
+}
+function literalValueOf(name, stored, schema, codecs = {}) {
+    const field = modeFields(schema).find((candidate)=>candidate.name === name);
+    return field ? readLiteral(stored, field, codecs) : stored;
+}
+function readLiteral(stored, field, codecs) {
+    const config = field.valueModes;
+    const codec = resolveCodec(codecs, config);
+    const ctx = codecContext(field, config);
+    const decoded = codec.decode(stored, ctx);
+    if (isDecodedEmpty(codec, decoded, ctx)) return;
+    return 'literal' === decoded.mode ? decoded.value : external_opaque_value_cjs_namespaceObject.VALUE_MODE_OPAQUE;
+}
+const modeFieldsCache = new WeakMap();
+function modeFields(schema) {
+    let fields = modeFieldsCache.get(schema);
+    if (!fields) {
+        const sections = schema.steps?.flatMap((step)=>step.sections) ?? schema.sections ?? [];
+        fields = sections.flatMap((section)=>section.fields).filter((field)=>field.valueModes);
+        modeFieldsCache.set(schema, fields);
+    }
+    return fields;
+}
+function withPath(target, path, value) {
+    const [key, ...rest] = path;
+    if (void 0 === key) return target;
+    const container = 'object' == typeof target && null !== target ? target : {};
+    const copy = Array.isArray(container) ? [
+        ...container
+    ] : {
+        ...container
+    };
+    copy[key] = rest.length ? withPath(copy[key], rest, value) : value;
+    return copy;
+}
+exports.DEFAULT_VALUE_MODE_REGISTRY = __webpack_exports__.DEFAULT_VALUE_MODE_REGISTRY;
+exports.VALUE_MODE_OPAQUE = __webpack_exports__.VALUE_MODE_OPAQUE;
+exports.buildValueModeRegistry = __webpack_exports__.buildValueModeRegistry;
+exports.codecContext = __webpack_exports__.codecContext;
+exports.convertValue = __webpack_exports__.convertValue;
+exports.envelopeCodec = __webpack_exports__.envelopeCodec;
+exports.isDecodedEmpty = __webpack_exports__.isDecodedEmpty;
+exports.isEmptyModeValue = __webpack_exports__.isEmptyModeValue;
+exports.isFieldControlRegistration = __webpack_exports__.isFieldControlRegistration;
+exports.isValueModeEnvelope = __webpack_exports__.isValueModeEnvelope;
+exports.literalValueOf = __webpack_exports__.literalValueOf;
+exports.literalValues = __webpack_exports__.literalValues;
+exports.resolveCodec = __webpack_exports__.resolveCodec;
+exports.resolveModeOptions = __webpack_exports__.resolveModeOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_VALUE_MODE_REGISTRY",
+    "VALUE_MODE_OPAQUE",
+    "buildValueModeRegistry",
+    "codecContext",
+    "convertValue",
+    "envelopeCodec",
+    "isDecodedEmpty",
+    "isEmptyModeValue",
+    "isFieldControlRegistration",
+    "isValueModeEnvelope",
+    "literalValueOf",
+    "literalValues",
+    "resolveCodec",
+    "resolveModeOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});