@crowdin/app-project-module 1.8.1 → 1.10.0

package/out/static/ui/form.bundle.js

@@ -21021,6 +21021,7 @@ export default theme;`;
 	const REQUIRED_KEY = 'required';
 	const SUBMIT_BTN_OPTIONS_KEY = 'submitButtonOptions';
 	const REF_KEY = '$ref';
+	const RJSF_REF_KEY = '__rjsf_ref';
 	const SCHEMA_KEY = '$schema';
 	const DEFAULT_ID_PREFIX = 'root';
 	const DEFAULT_ID_SEPARATOR = '_';
@@ -22061,7 +22062,7 @@ export default theme;`;
 	 * @name has
 	 * @memberOf SetCache
 	 * @param {*} value The value to search for.
-	 * @returns {number} Returns `true` if `value` is found, else `false`.
+	 * @returns {boolean} Returns `true` if `value` is found, else `false`.
 	 */
 	function setCacheHas(value) {
 	  return this.__data__.has(value);
@@ -27042,7 +27043,9 @@ export default theme;`;
 	function baseUnset(object, path) {
 	  path = castPath(path, object);
 
-	  // Prevent prototype pollution, see: https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+	  // Prevent prototype pollution:
+	  // https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+	  // https://github.com/lodash/lodash/security/advisories/GHSA-f23m-r3pf-42rh
 	  var index = -1,
 	      length = path.length;
 
@@ -27050,32 +27053,17 @@ export default theme;`;
 	    return true;
 	  }
 
-	  var isRootPrimitive = object == null || (typeof object !== 'object' && typeof object !== 'function');
-
 	  while (++index < length) {
-	    var key = path[index];
-
-	    // skip non-string keys (e.g., Symbols, numbers)
-	    if (typeof key !== 'string') {
-	      continue;
-	    }
+	    var key = toKey(path[index]);
 
 	    // Always block "__proto__" anywhere in the path if it's not expected
 	    if (key === '__proto__' && !hasOwnProperty$1.call(object, '__proto__')) {
 	      return false;
 	    }
 
-	    // Block "constructor.prototype" chains
-	    if (key === 'constructor' &&
-	        (index + 1) < length &&
-	        typeof path[index + 1] === 'string' &&
-	        path[index + 1] === 'prototype') {
-
-	      // Allow ONLY when the path starts at a primitive root, e.g., _.unset(0, 'constructor.prototype.a')
-	      if (isRootPrimitive && index === 0) {
-	        continue;
-	      }
-
+	    // Block constructor/prototype as non-terminal traversal keys to prevent
+	    // escaping the object graph into built-in constructors and prototypes.
+	    if ((key === 'constructor' || key === 'prototype') && index < length - 1) {
 	      return false;
 	    }
 	  }
@@ -28781,7 +28769,7 @@ export default theme;`;
 	        recurseList.push($ref);
 	        // Retrieve the referenced schema definition.
 	        const refSchema = findSchemaDefinition($ref, rootSchema, baseURI);
-	        resolvedSchema = { ...refSchema, ...localSchema };
+	        resolvedSchema = { ...refSchema, ...localSchema, [RJSF_REF_KEY]: $ref };
 	        if (ID_KEY in resolvedSchema) {
 	            baseURI = resolvedSchema[ID_KEY];
 	        }
@@ -29805,6 +29793,22 @@ export default theme;`;
 	    throw new Error('schema cannot be inferred as a constant');
 	}
 
+	/** Reorders `options` according to `order`, which may contain a `'*'` wildcard representing all
+	 * remaining options in their original order. Options not listed in `order` (and not covered by
+	 * a wildcard) are dropped.
+	 */
+	function applyEnumOrder(options, order) {
+	    const optionsByValue = new Map(options.map((opt) => [String(opt.value), opt]));
+	    const orderedKeys = new Set(order.filter((v) => v !== '*').map(String));
+	    const rest = options.filter((opt) => !orderedKeys.has(String(opt.value)));
+	    return order.flatMap((entry) => {
+	        if (entry === '*') {
+	            return rest;
+	        }
+	        const opt = optionsByValue.get(String(entry));
+	        return opt ? [opt] : [];
+	    });
+	}
 	/** Gets the list of options from the `schema`. If the schema has an enum list, then those enum values are returned. The
 	 * label will be the same as the `value`.
 	 *
@@ -29821,14 +29825,22 @@ export default theme;`;
 	function optionsList(schema, uiSchema) {
 	    if (schema.enum) {
 	        let enumNames;
+	        let enumOrder;
 	        if (uiSchema) {
-	            const { enumNames: uiEnumNames } = getUiOptions(uiSchema);
+	            const { enumNames: uiEnumNames, enumOrder: uiEnumOrder } = getUiOptions(uiSchema);
 	            enumNames = uiEnumNames;
+	            enumOrder = uiEnumOrder;
 	        }
-	        return schema.enum.map((value, i) => {
-	            const label = (enumNames === null || enumNames === void 0 ? void 0 : enumNames[i]) || String(value);
+	        let options = schema.enum.map((value, i) => {
+	            const label = Array.isArray(enumNames)
+	                ? enumNames[i] || String(value)
+	                : (enumNames === null || enumNames === void 0 ? void 0 : enumNames[String(value)]) || String(value);
 	            return { label, value };
 	        });
+	        if (enumOrder) {
+	            options = applyEnumOrder(options, enumOrder);
+	        }
+	        return options;
 	    }
 	    let altSchemas = undefined;
 	    let altUiSchemas = undefined;
@@ -30586,6 +30598,13 @@ export default theme;`;
 	    }
 	    if (ADDITIONAL_PROPERTIES_KEY in schema && schema[ADDITIONAL_PROPERTIES_KEY] !== false) {
 	        set(pathSchema, RJSF_ADDITIONAL_PROPERTIES_FLAG, true);
+	        const additionalSchema = (isObject$2(schema[ADDITIONAL_PROPERTIES_KEY]) ? schema[ADDITIONAL_PROPERTIES_KEY] : {});
+	        const definedProperties = get(schema, PROPERTIES_KEY, {});
+	        for (const key of Object.keys((formData !== null && formData !== void 0 ? formData : {}))) {
+	            if (!(key in definedProperties)) {
+	                pathSchema[key] = toPathSchemaInternal(validator, additionalSchema, `${name}.${key}`, rootSchema, get(formData, [key]), _recurseList, experimental_customMergeAllOf);
+	            }
+	        }
 	    }
 	    if (ITEMS_KEY in schema && Array.isArray(formData)) {
 	        const { items: schemaItems, additionalItems: schemaAdditionalItems } = schema;
@@ -32210,7 +32229,7 @@ export default theme;`;
 	    }
 	    if (REF_KEY in rootSchema) {
 	        const resolvedSchema = schemaUtils.retrieveSchema(rootSchema);
-	        return isEqual(schemaToCompare, resolvedSchema);
+	        return isEqual(schemaToCompare, omit(resolvedSchema, RJSF_REF_KEY));
 	    }
 	    return false;
 	}
@@ -32418,9 +32437,9 @@ export default theme;`;
 	 * @returns - The resolved uiSchema with definitions merged in
 	 */
 	function resolveUiSchema(schema, localUiSchema, registry) {
-	    var _a;
-	    const ref = schema[REF_KEY];
-	    const definitionUiSchema = ref ? (_a = registry.uiSchemaDefinitions) === null || _a === void 0 ? void 0 : _a[ref] : undefined;
+	    var _a, _b;
+	    const ref = ((_a = schema[RJSF_REF_KEY]) !== null && _a !== void 0 ? _a : schema[REF_KEY]);
+	    const definitionUiSchema = ref ? (_b = registry.uiSchemaDefinitions) === null || _b === void 0 ? void 0 : _b[ref] : undefined;
 	    if (!definitionUiSchema) {
 	        return localUiSchema || {};
 	    }
@@ -33262,7 +33281,10 @@ export default theme;`;
 	    const { schema, fieldPathId, uiSchema, formData: items = [], disabled = false, readonly = false, autofocus = false, required = false, placeholder, onBlur, onFocus, registry, rawErrors, name, onSelectChange, } = props;
 	    const { widgets, schemaUtils, globalFormOptions, globalUiOptions } = registry;
 	    const itemsSchema = schemaUtils.retrieveSchema(schema.items, items);
-	    const enumOptions = optionsList(itemsSchema, uiSchema);
+	    // For computing `enumOptions`, fallback to the array property's uiSchema if there is no `items` schema
+	    // Avoids a breaking change reported in https://github.com/rjsf-team/react-jsonschema-form/issues/4985
+	    const itemsUiSchema = (uiSchema?.items ?? uiSchema);
+	    const enumOptions = optionsList(itemsSchema, itemsUiSchema);
 	    const { widget = 'select', title: uiTitle, ...options } = getUiOptions(uiSchema, globalUiOptions);
 	    const Widget = getWidget(schema, widget, widgets);
 	    const label = uiTitle ?? schema.title ?? name;
@@ -33407,6 +33429,7 @@ export default theme;`;
 	                name: name && `${name}-${index}`,
 	                registry,
 	                uiOptions,
+	                parentUiSchema: uiSchema,
 	                hideError,
 	                readonly,
 	                disabled,
@@ -33517,6 +33540,7 @@ export default theme;`;
 	                name: name && `${name}-${index}`,
 	                registry,
 	                uiOptions,
+	                parentUiSchema: uiSchema,
 	                hideError,
 	                readonly,
 	                disabled,
@@ -36590,6 +36614,30 @@ export default theme;`;
 	     * This prevents componentDidUpdate from reverting oneOf/anyOf option switches.
 	     */
 	    _isProcessingUserChange = false;
+	    /** When the `extraErrors` prop changes, re-merges `schemaValidationErrors` + `extraErrors` + `customErrors` into
+	     * state before render, ensuring the updated errors are visible immediately in a single render cycle.
+	     *
+	     * @param props - The current props
+	     * @param state - The current state
+	     * @returns Partial state with re-merged errors if `extraErrors` changed, or `null` if no update is needed
+	     */
+	    static getDerivedStateFromProps(props, state) {
+	        if (props.extraErrors !== state._prevExtraErrors) {
+	            const baseErrors = {
+	                errors: state.schemaValidationErrors || [],
+	                errorSchema: (state.schemaValidationErrorSchema || {}),
+	            };
+	            let { errors, errorSchema } = baseErrors;
+	            if (props.extraErrors) {
+	                ({ errors, errorSchema } = validationDataMerge(baseErrors, props.extraErrors));
+	            }
+	            if (state.customErrors) {
+	                ({ errors, errorSchema } = validationDataMerge({ errors, errorSchema }, state.customErrors.ErrorSchema, true));
+	            }
+	            return { _prevExtraErrors: props.extraErrors, errors, errorSchema };
+	        }
+	        return null;
+	    }
 	    /** Constructs the `Form` from the `props`. Will setup the initial state from the props. It will also call the
 	     * `onChange` handler if the initially provided `formData` is modified to add missing default values as part of the
 	     * state construction.
@@ -36603,7 +36651,10 @@ export default theme;`;
 	        }
 	        const { formData: propsFormData, initialFormData, onChange } = props;
 	        const formData = propsFormData ?? initialFormData;
-	        this.state = this.getStateFromProps(props, formData, undefined, undefined, undefined, true);
+	        this.state = {
+	            ...this.getStateFromProps(props, formData, undefined, undefined, undefined, true),
+	            _prevExtraErrors: props.extraErrors,
+	        };
 	        if (onChange && !deepEquals(this.state.formData, formData)) {
 	            onChange(toIChangeEvent(this.state));
 	        }
@@ -36852,7 +36903,7 @@ export default theme;`;
 	            errors = merged.errors;
 	        }
 	        if (customErrors) {
-	            const merged = validationDataMerge(schemaValidation, customErrors.ErrorSchema, true);
+	            const merged = validationDataMerge({ errors, errorSchema }, customErrors.ErrorSchema, true);
 	            errorSchema = merged.errorSchema;
 	            errors = merged.errors;
 	        }
@@ -37275,17 +37326,12 @@ export default theme;`;
 	        const { extraErrors, extraErrorsBlockSubmit, focusOnFirstError, onError } = this.props;
 	        const { errors: prevErrors } = this.state;
 	        const schemaValidation = this.validate(formData);
-	        let errors = schemaValidation.errors;
-	        let errorSchema = schemaValidation.errorSchema;
-	        const schemaValidationErrors = errors;
-	        const schemaValidationErrorSchema = errorSchema;
-	        const hasError = errors.length > 0 || (extraErrors && extraErrorsBlockSubmit);
+	        // Always merge extraErrors so they remain visible in state regardless of extraErrorsBlockSubmit.
+	        const { errors, errorSchema } = extraErrors ? this.mergeErrors(schemaValidation, extraErrors) : schemaValidation;
+	        // hasError gates submission: schema errors always block; extraErrors only block when
+	        // extraErrorsBlockSubmit is set (non-breaking default: extraErrors are informational only).
+	        const hasError = schemaValidation.errors.length > 0 || (extraErrors && extraErrorsBlockSubmit);
 	        if (hasError) {
-	            if (extraErrors) {
-	                const merged = validationDataMerge(schemaValidation, extraErrors);
-	                errorSchema = merged.errorSchema;
-	                errors = merged.errors;
-	            }
 	            if (focusOnFirstError) {
 	                if (typeof focusOnFirstError === 'function') {
 	                    focusOnFirstError(errors[0]);
@@ -37297,8 +37343,8 @@ export default theme;`;
 	            this.setState({
 	                errors,
 	                errorSchema,
-	                schemaValidationErrors,
-	                schemaValidationErrorSchema,
+	                schemaValidationErrors: schemaValidation.errors,
+	                schemaValidationErrorSchema: schemaValidation.errorSchema,
 	            }, () => {
 	                if (onError) {
 	                    onError(errors);
@@ -37308,6 +37354,15 @@ export default theme;`;
 	                }
 	            });
 	        }
+	        else if (errors.length > 0) {
+	            // Non-blocking extraErrors are present — update display state without triggering onError.
+	            this.setState({
+	                errors,
+	                errorSchema,
+	                schemaValidationErrors: [],
+	                schemaValidationErrorSchema: {},
+	            });
+	        }
 	        else if (prevErrors.length > 0) {
 	            this.setState({
 	                errors: [],