@oracle/oraclejet-core-pack 17.1.4 → 18.0.1

package/oj-c/editable-value/UNSAFE_useEditableValue/useEditableValue.js

@@ -1,152 +0,0 @@
-define(["require", "exports", "preact/hooks", "../UNSAFE_useComponentMessaging/useComponentMessaging", "../UNSAFE_useConverter/useConverter", "../UNSAFE_useConverterLifecycle/useConverterLifecycle", "../UNSAFE_useDeferredValidators/useDeferredValidators", "../UNSAFE_useValidationLifecycle/useValidationLifecycle", "../UNSAFE_useValidators/useValidators", "../UNSAFE_useValue/useValue", "../UNSAFE_useValueLifecycle/useValueLifecycle", "../utils/utils"], function (require, exports, hooks_1, useComponentMessaging_1, useConverter_1, useConverterLifecycle_1, useDeferredValidators_1, useValidationLifecycle_1, useValidators_1, useValue_1, useValueLifecycle_1, utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useEditableValue = void 0;
-    function useEditableValue({ ariaDescribedBy, converter, disabled, displayOptions, implicitComponentValidator, labelHint, messagesCustom, readonly, required, requiredMessageDetail, shouldNormalizeValueOnCommit = true, validators, value: valueProp, addBusyState, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, onTransientValueChanged, wrapValueState }) {
-        const componentMessagingState = (0, useComponentMessaging_1.useComponentMessaging)({
-            messagesCustom,
-            onMessagesCustomChanged
-        });
-        const { clearAllMessages, visibleMessages } = componentMessagingState;
-        const deferredValidators = (0, useDeferredValidators_1.useDeferredValidators)({
-            labelHint,
-            required,
-            requiredMessageDetail
-        });
-        const combinedValidators = !implicitComponentValidator
-            ? validators
-            : validators
-                ? [implicitComponentValidator, ...validators]
-                : [implicitComponentValidator];
-        const validationState = (0, useValidators_1.useValidators)({
-            componentMessagingState,
-            defaultValidState: 'valid',
-            deferredValidators,
-            validators: combinedValidators,
-            addBusyState,
-            onValidChanged
-        });
-        const { validateValueOnExternalChange, validateValueOnInternalChange } = validationState;
-        const { format, parse } = (0, useConverter_1.useConverter)({
-            componentMessagingState,
-            converter,
-            validationState
-        });
-        const defaultValueState = (0, useValue_1.useValue)({
-            value: valueProp,
-            format,
-            parse,
-            onRawValueChanged,
-            onTransientValueChanged,
-            onValueChanged
-        });
-        const valueState = wrapValueState ? wrapValueState(defaultValueState) : defaultValueState;
-        const { displayValue, value, getValueForValidation, setValueAfterValidation, refreshDisplayValue, setDisplayValue, setTransientValue, setValue } = valueState;
-        const { runFullValidationAndUpdateValue } = (0, useValidationLifecycle_1.useValidationLifecycle)({
-            componentMessagingState,
-            validationState,
-            deferredValidators,
-            validators,
-            getValueForValidation,
-            setValueAfterValidation,
-            readonly,
-            disabled
-        });
-        (0, useConverterLifecycle_1.useConverterLifecycle)({
-            converter,
-            validationState,
-            value: valueProp,
-            refreshDisplayValue,
-            runFullValidationAndUpdateValue
-        });
-        (0, useValueLifecycle_1.useValueLifecycle)({
-            value: valueProp,
-            valueState,
-            format,
-            validateValueOnExternalChange
-        });
-        const normalizeAndParseValue = (0, hooks_1.useCallback)((value) => {
-            return parse(shouldNormalizeValueOnCommit ? (0, utils_1.normalizeValue)(value) : value);
-        }, [shouldNormalizeValueOnCommit, parse]);
-        const onCommitValue = (0, hooks_1.useCallback)(async (value, doCommitOnValid = true) => {
-            const validationResult = await validateValueOnInternalChange(value);
-            if (validationResult === useValidators_1.ValidationResult.VALID && doCommitOnValid) {
-                setValue(value);
-            }
-            return validationResult;
-        }, [validateValueOnInternalChange]);
-        const onCommit = (0, hooks_1.useCallback)(async ({ value }) => {
-            const parsedValueOrSymbol = normalizeAndParseValue(value);
-            if (parsedValueOrSymbol === useConverter_1.ConverterErrorSymbol) {
-                return;
-            }
-            const parsedValue = parsedValueOrSymbol;
-            const validationResult = await onCommitValue(parsedValue);
-            if (validationResult === useValidators_1.ValidationResult.VALID) {
-                setDisplayValue(format(parsedValue));
-            }
-        }, [format, onCommitValue, normalizeAndParseValue]);
-        const onInput = (0, hooks_1.useCallback)(({ value }) => {
-            setDisplayValue(value ?? '');
-        }, []);
-        const reset = (0, hooks_1.useCallback)(() => {
-            clearAllMessages();
-            validateValueOnExternalChange(value);
-            refreshDisplayValue(value);
-        }, [value, clearAllMessages, refreshDisplayValue, validateValueOnExternalChange]);
-        const validate = (0, hooks_1.useCallback)(async () => {
-            if (readonly || disabled) {
-                return 'valid';
-            }
-            const { fullValidate } = validationState;
-            const { displayValue, value, setValueAfterValidation } = valueState;
-            const newValueOrSymbol = normalizeAndParseValue(displayValue);
-            if (newValueOrSymbol === useConverter_1.ConverterErrorSymbol) {
-                return 'invalid';
-            }
-            const newValue = newValueOrSymbol;
-            const resolver = addBusyState?.('running component method validate');
-            const validateResult = await fullValidate(newValue);
-            resolver?.();
-            if (validateResult) {
-                if (newValue !== value) {
-                    setValueAfterValidation(newValue);
-                }
-                return 'valid';
-            }
-            return 'invalid';
-        }, [validationState, valueState, addBusyState, normalizeAndParseValue, readonly, disabled]);
-        const showMessages = (0, hooks_1.useCallback)(() => {
-            const { hasHiddenMessages, showHiddenMessages } = componentMessagingState;
-            const { setValid } = validationState;
-            if (hasHiddenMessages()) {
-                showHiddenMessages();
-                setValid('invalidShown');
-            }
-        }, [componentMessagingState, validationState]);
-        return {
-            value,
-            setValue,
-            displayValue,
-            setDisplayValue,
-            setTransientValue,
-            methods: {
-                reset,
-                validate,
-                showMessages
-            },
-            textFieldProps: {
-                messages: displayOptions?.messages !== 'none' ? visibleMessages : undefined,
-                value: displayValue,
-                'aria-describedby': ariaDescribedBy,
-                onCommit,
-                onInput
-            },
-            onCommitValue,
-            format,
-            normalizeAndParseValue,
-            validateValueOnExternalChange
-        };
-    }
-    exports.useEditableValue = useEditableValue;
-});

package/oj-c/editable-value/UNSAFE_useValidationLifecycle/useValidationLifecycle.js

@@ -1,138 +0,0 @@
-define(["require", "exports", "preact/hooks", "../UNSAFE_useConverter/useConverter", "../UNSAFE_useValidators/useValidators", "../utils/utils"], function (require, exports, hooks_1, useConverter_1, useValidators_1, utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useValidationLifecycle = void 0;
-    function useValidationLifecycle({ componentMessagingState, disabled, deferredValidators, readonly, validationState, validators, getValueForValidation, setValueAfterValidation }) {
-        const prevDeferredValidatorsRef = (0, hooks_1.useRef)(deferredValidators);
-        const prevValidatorsRef = (0, hooks_1.useRef)(validators);
-        const prevMessagesCustomRef = (0, hooks_1.useRef)(componentMessagingState.messagesCustom);
-        const prevReadonlyRef = (0, hooks_1.useRef)(readonly);
-        const prevDisabledRef = (0, hooks_1.useRef)(disabled);
-        const isFirstRender = (0, hooks_1.useRef)(true);
-        const runFullValidationAndUpdateValue = (0, hooks_1.useCallback)(async () => {
-            if (readonly || disabled)
-                return;
-            const { valid, validateValueOnInternalChange } = validationState;
-            const value = getValueForValidation(valid);
-            if (value === useConverter_1.ConverterErrorSymbol) {
-                return;
-            }
-            const validationResult = await validateValueOnInternalChange(value, {
-                doNotClearMessagesCustom: true
-            });
-            if (validationResult === useValidators_1.ValidationResult.VALID) {
-                setValueAfterValidation(value);
-            }
-        }, [disabled, readonly, validationState, getValueForValidation, setValueAfterValidation]);
-        (0, hooks_1.useEffect)(() => {
-            if (!isFirstRender.current)
-                return;
-            isFirstRender.current = false;
-            if (readonly || disabled) {
-                return;
-            }
-            const value = getValueForValidation('valid');
-            if (value === useConverter_1.ConverterErrorSymbol) {
-                return;
-            }
-            const { deferredValidate, setValid } = validationState;
-            const { hasCustomErrorMessages, setDeferredComponentMessages } = componentMessagingState;
-            const maybeErrors = deferredValidate(value);
-            if (maybeErrors) {
-                setDeferredComponentMessages(maybeErrors);
-                setValid('invalidHidden');
-            }
-            if (hasCustomErrorMessages()) {
-                setValid('invalidShown');
-            }
-        }, [disabled, readonly]);
-        (0, hooks_1.useEffect)(() => {
-            const isRequiredToggledToFalse = prevDeferredValidatorsRef.current !== deferredValidators && deferredValidators.length === 0;
-            if (prevDeferredValidatorsRef.current === deferredValidators &&
-                prevReadonlyRef.current === readonly &&
-                prevDisabledRef.current === disabled) {
-                return;
-            }
-            else {
-                prevReadonlyRef.current = readonly;
-                prevDisabledRef.current = disabled;
-                prevDeferredValidatorsRef.current = deferredValidators;
-            }
-            const runValidation = isRequiredToggledToFalse || (!readonly && !disabled);
-            if (!runValidation) {
-                return;
-            }
-            const { valid, deferredValidate, setValid } = validationState;
-            const { clearDeferredComponentMessages, setDeferredComponentMessages } = componentMessagingState;
-            switch (valid) {
-                case 'valid':
-                    const value = getValueForValidation(valid);
-                    if (value !== useConverter_1.ConverterErrorSymbol) {
-                        const maybeErrors = deferredValidate(value);
-                        if (maybeErrors) {
-                            setDeferredComponentMessages(maybeErrors);
-                            setValid('invalidHidden');
-                        }
-                    }
-                    break;
-                case 'invalidHidden':
-                    if (deferredValidators.length === 0) {
-                        setValid('valid');
-                        clearDeferredComponentMessages();
-                    }
-                    break;
-                case 'invalidShown':
-                    runFullValidationAndUpdateValue();
-                    break;
-            }
-        }, [
-            disabled,
-            readonly,
-            deferredValidators,
-            componentMessagingState,
-            validationState,
-            getValueForValidation,
-            runFullValidationAndUpdateValue
-        ]);
-        (0, hooks_1.useEffect)(() => {
-            if (prevValidatorsRef.current === validators) {
-                return;
-            }
-            else {
-                prevValidatorsRef.current = validators;
-            }
-            if (readonly || disabled) {
-                return;
-            }
-            switch (validationState.valid) {
-                case 'invalidShown':
-                    runFullValidationAndUpdateValue();
-                    break;
-            }
-        }, [disabled, readonly, validators, validationState]);
-        (0, hooks_1.useEffect)(() => {
-            if ((0, utils_1.isShallowEqual)(prevMessagesCustomRef.current, componentMessagingState.messagesCustom)) {
-                return;
-            }
-            const { messagesCustom, hasCustomErrorMessages, hasHiddenMessages, hasNoErrorMessages } = componentMessagingState;
-            const { valid, setValid } = validationState;
-            prevMessagesCustomRef.current = messagesCustom;
-            if (hasCustomErrorMessages()) {
-                setValid('invalidShown');
-            }
-            else if (valid === 'pending') {
-                return;
-            }
-            else if (hasNoErrorMessages()) {
-                setValid('valid');
-            }
-            else if (hasHiddenMessages()) {
-                setValid('invalidHidden');
-            }
-        }, [componentMessagingState, validationState]);
-        return {
-            runFullValidationAndUpdateValue
-        };
-    }
-    exports.useValidationLifecycle = useValidationLifecycle;
-});

package/oj-c/editable-value/UNSAFE_useValidators/useValidators.js

@@ -1,168 +0,0 @@
-define(["require", "exports", "@oracle/oraclejet-preact/hooks/UNSAFE_useUncontrolledState", "preact/hooks", "../UNSAFE_useStaleIdentity/useStaleIdentity", "../utils/utils"], function (require, exports, UNSAFE_useUncontrolledState_1, hooks_1, useStaleIdentity_1, utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useValidators = exports.ValidationResult = void 0;
-    exports.ValidationResult = {
-        VALID: 'VALID',
-        INVALID: 'INVALID',
-        STALE: 'STALE'
-    };
-    function useValidators({ componentMessagingState, defaultValidState, deferredValidators = [], validators = [], addBusyState, onValidChanged }) {
-        const [valid, setValid] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(defaultValidState, onValidChanged);
-        const { setStaleIdentity } = (0, useStaleIdentity_1.useStaleIdentity)();
-        (0, hooks_1.useLayoutEffect)(() => {
-            if (defaultValidState !== undefined) {
-                onValidChanged?.(defaultValidState);
-            }
-        }, []);
-        const { addComponentMessage, clearAllComponentMessages, clearAllMessages, hasCustomErrorMessages, setComponentMessages } = componentMessagingState;
-        const fullValidate = (0, hooks_1.useCallback)(async (value, options = {}) => {
-            const { doNotClearMessagesCustom = false } = options;
-            const hadCustomErrorMessages = hasCustomErrorMessages();
-            setValid('pending');
-            if (doNotClearMessagesCustom) {
-                clearAllComponentMessages();
-            }
-            else {
-                clearAllMessages();
-            }
-            if (validators.length === 0 && deferredValidators.length === 0) {
-                if (hadCustomErrorMessages && doNotClearMessagesCustom) {
-                    setValid('invalidShown');
-                }
-                else {
-                    setValid('valid');
-                }
-                return true;
-            }
-            function nonDeferredValidate(validator, value) {
-                try {
-                    const validateResult = validator.validate(value);
-                    if (validateResult instanceof Promise) {
-                        return validateResult.then(() => { }, (error) => (0, utils_1.createMessageFromError)(error));
-                    }
-                }
-                catch (error) {
-                    return (0, utils_1.createMessageFromError)(error);
-                }
-                return;
-            }
-            const errors = [];
-            const maybeErrorsPromise = [];
-            const deferredErrors = deferredValidate(value);
-            if (deferredErrors !== undefined) {
-                errors.push(...deferredErrors);
-            }
-            if (value !== null && value !== undefined) {
-                for (const validator of validators) {
-                    const maybeComponentMessageItem = nonDeferredValidate(validator, value);
-                    if (maybeComponentMessageItem !== undefined) {
-                        if (maybeComponentMessageItem instanceof Promise) {
-                            maybeErrorsPromise.push(maybeComponentMessageItem);
-                        }
-                        else {
-                            errors.push(maybeComponentMessageItem);
-                        }
-                    }
-                }
-            }
-            if (!errors.length && !maybeErrorsPromise.length) {
-                if (hadCustomErrorMessages && doNotClearMessagesCustom) {
-                    setValid('invalidShown');
-                }
-                else {
-                    setValid('valid');
-                }
-                return true;
-            }
-            const hasSyncError = errors.length !== 0;
-            if (hasSyncError) {
-                setComponentMessages(errors);
-                setValid('invalidShown');
-            }
-            if (!maybeErrorsPromise.length) {
-                return !hasSyncError;
-            }
-            const resolver = addBusyState?.('running validation');
-            const { isStale } = setStaleIdentity('useValidators-validate');
-            let hasAsyncError = false;
-            for (const asyncValidationResult of maybeErrorsPromise) {
-                const maybeValidationError = await asyncValidationResult;
-                if (maybeValidationError && !isStale()) {
-                    addComponentMessage(maybeValidationError);
-                    setValid('invalidShown');
-                    hasAsyncError = true;
-                }
-            }
-            if (!hasSyncError && !hasAsyncError && !isStale()) {
-                if (hadCustomErrorMessages && doNotClearMessagesCustom) {
-                    setValid('invalidShown');
-                }
-                else {
-                    setValid('valid');
-                }
-            }
-            resolver?.();
-            return !hasSyncError && !hasAsyncError;
-        }, [
-            addComponentMessage,
-            clearAllComponentMessages,
-            clearAllMessages,
-            deferredValidators,
-            validators
-        ]);
-        const deferredValidate = (0, hooks_1.useCallback)((value) => {
-            const errors = [];
-            for (const validator of deferredValidators) {
-                try {
-                    validator.validate(value);
-                }
-                catch (error) {
-                    errors.push((0, utils_1.createMessageFromError)(error));
-                }
-            }
-            if (errors.length) {
-                return errors;
-            }
-            return undefined;
-        }, [deferredValidators]);
-        const validateValueOnInternalChange = (0, hooks_1.useCallback)(async (value, options = {}) => {
-            const { isStale } = setStaleIdentity('useValidationLifeCycle-validateValueOnInternalChange');
-            const resolver = addBusyState?.('running validateValueOnInternalChange');
-            const validationResult = await fullValidate(value, options);
-            resolver?.();
-            if (isStale()) {
-                return exports.ValidationResult.STALE;
-            }
-            return validationResult ? exports.ValidationResult.VALID : exports.ValidationResult.INVALID;
-        }, [addBusyState, fullValidate]);
-        const validateValueOnExternalChange = (0, hooks_1.useCallback)((value) => {
-            const { clearAllMessages, setDeferredComponentMessages } = componentMessagingState;
-            clearAllMessages();
-            const maybeErrors = deferredValidate(value);
-            if (maybeErrors) {
-                setDeferredComponentMessages(maybeErrors);
-                setValid('invalidHidden');
-            }
-            else {
-                setValid('valid');
-            }
-            return exports.ValidationResult.VALID;
-        }, [componentMessagingState, deferredValidate]);
-        return (0, hooks_1.useMemo)(() => ({
-            valid,
-            setValid,
-            deferredValidate,
-            fullValidate,
-            validateValueOnExternalChange,
-            validateValueOnInternalChange
-        }), [
-            valid,
-            deferredValidate,
-            fullValidate,
-            validateValueOnExternalChange,
-            validateValueOnInternalChange
-        ]);
-    }
-    exports.useValidators = useValidators;
-});

package/oj-c/editable-value/UNSAFE_useValue/useValue.js

@@ -1,42 +0,0 @@
-define(["require", "exports", "@oracle/oraclejet-preact/hooks/UNSAFE_useUncontrolledState", "preact/hooks", "../utils/utils"], function (require, exports, UNSAFE_useUncontrolledState_1, hooks_1, utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useValue = void 0;
-    function useValue({ value: valueProp, format, parse, onRawValueChanged, onTransientValueChanged, onValueChanged }) {
-        const [displayValue, setDisplayValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(format(valueProp, true), onRawValueChanged);
-        const [value, setValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(valueProp, onValueChanged);
-        (0, hooks_1.useEffect)(() => {
-            if (displayValue !== undefined) {
-                onRawValueChanged?.(displayValue);
-            }
-        }, []);
-        const [transientValue, setTransientValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(valueProp, onTransientValueChanged);
-        (0, hooks_1.useEffect)(() => {
-            if (valueProp !== undefined) {
-                onTransientValueChanged?.(valueProp);
-            }
-        }, []);
-        return {
-            displayValue,
-            transientValue,
-            value,
-            getValueForValidation: (0, hooks_1.useCallback)((valid) => {
-                if (valid !== 'invalidShown') {
-                    return value;
-                }
-                return parse((0, utils_1.normalizeValue)(displayValue));
-            }, [displayValue, value, parse]),
-            setValueAfterValidation: (0, hooks_1.useCallback)((value) => {
-                setValue(value);
-                setDisplayValue(format(value));
-            }, [format, setDisplayValue, setValue]),
-            setDisplayValue,
-            setTransientValue,
-            setValue,
-            refreshDisplayValue: (0, hooks_1.useCallback)((value) => {
-                setDisplayValue(format(value));
-            }, [format, setDisplayValue])
-        };
-    }
-    exports.useValue = useValue;
-});

package/oj-c/editable-value/UNSAFE_useValueLifecycle/useValueLifecycle.js

@@ -1,24 +0,0 @@
-define(["require", "exports", "preact/hooks", "../UNSAFE_useValidators/useValidators"], function (require, exports, hooks_1, useValidators_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useValueLifecycle = void 0;
-    function useValueLifecycle({ value, valueState, format, validateValueOnExternalChange }) {
-        const previousValueRef = (0, hooks_1.useRef)(value);
-        (0, hooks_1.useEffect)(() => {
-            const { value, setDisplayValue } = valueState;
-            setDisplayValue(format(value));
-        }, []);
-        if (previousValueRef.current !== value) {
-            previousValueRef.current = value;
-            if (value !== undefined && value !== valueState.value) {
-                const { setDisplayValue, setValue } = valueState;
-                const validationResult = validateValueOnExternalChange(value);
-                if (validationResult === useValidators_1.ValidationResult.VALID) {
-                    setValue(value);
-                    setDisplayValue(format(value));
-                }
-            }
-        }
-    }
-    exports.useValueLifecycle = useValueLifecycle;
-});

package/oj-c/editable-value/utils/utils.js

@@ -1,43 +0,0 @@
-define(["require", "exports"], function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isShallowEqual = exports.normalizeValue = exports.treatNull = exports.getVirtualKeyboardHintFromConverter = exports.createMessageFromError = void 0;
-    function createMessageFromError(error) {
-        if (typeof error.getMessage === 'function') {
-            return {
-                severity: 'error',
-                detail: error.getMessage().detail
-            };
-        }
-        return { severity: 'error', detail: error.message };
-    }
-    exports.createMessageFromError = createMessageFromError;
-    function getVirtualKeyboardHintFromConverter(converter) {
-        let virtualKeyboardHint;
-        if (converter && converter.resolvedOptions) {
-            const resOptions = converter.resolvedOptions();
-            virtualKeyboardHint = resOptions?.virtualKeyboardHint ?? 'text';
-        }
-        else {
-            virtualKeyboardHint = 'text';
-        }
-        return virtualKeyboardHint;
-    }
-    exports.getVirtualKeyboardHintFromConverter = getVirtualKeyboardHintFromConverter;
-    function treatNull(value, defaultValue) {
-        if (value === null) {
-            return defaultValue;
-        }
-        return value;
-    }
-    exports.treatNull = treatNull;
-    function normalizeValue(value) {
-        if (typeof value === 'string' && value === '') {
-            return null;
-        }
-        return value;
-    }
-    exports.normalizeValue = normalizeValue;
-    const isShallowEqual = (a, b) => a === b || (a.length === b.length && a.every((v, i) => v === b[i]));
-    exports.isShallowEqual = isShallowEqual;
-});

package/oj-c/min/editable-value/UNSAFE_useComponentMessaging/useComponentMessaging.js

@@ -1,80 +0,0 @@
-define(["require", "exports", "@oracle/oraclejet-preact/hooks/UNSAFE_useUncontrolledState", "preact/hooks", "../utils/utils"], function (require, exports, UNSAFE_useUncontrolledState_1, hooks_1, utils_1) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.useComponentMessaging = void 0;
-    function useComponentMessaging({ messagesCustom: messagesCustomProp = [], onMessagesCustomChanged }) {
-        const [messagesCustom, setMessagesCustom] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(messagesCustomProp, onMessagesCustomChanged);
-        const [componentMessages, setComponentMessages] = (0, hooks_1.useState)([]);
-        const [deferredComponentMessages, setDeferredComponentMessages] = (0, hooks_1.useState)([]);
-        const prevMessagesCustomPropRef = (0, hooks_1.useRef)(messagesCustomProp);
-        const addComponentMessage = (0, hooks_1.useCallback)((...messages) => {
-            setComponentMessages((prevMessages) => [...prevMessages, ...messages]);
-        }, []);
-        const addDeferredComponentMessage = (0, hooks_1.useCallback)((message) => {
-            setComponentMessages((prevMessages) => [...prevMessages, message]);
-        }, []);
-        const clearAllComponentMessages = (0, hooks_1.useCallback)(() => {
-            setComponentMessages([]);
-            setDeferredComponentMessages([]);
-        }, []);
-        const clearDeferredComponentMessages = (0, hooks_1.useCallback)(() => {
-            setDeferredComponentMessages([]);
-        }, []);
-        const clearAllMessages = (0, hooks_1.useCallback)(() => {
-            setComponentMessages([]);
-            setDeferredComponentMessages([]);
-            setMessagesCustom([]);
-        }, []);
-        const hasCustomErrorMessages = (0, hooks_1.useCallback)(() => {
-            return messagesCustom.some((message) => message.severity === 'error');
-        }, [messagesCustom]);
-        const hasNoErrorMessages = (0, hooks_1.useCallback)(() => {
-            return (componentMessages.length === 0 &&
-                deferredComponentMessages.length === 0 &&
-                hasCustomErrorMessages() === false);
-        }, [componentMessages, deferredComponentMessages, hasCustomErrorMessages]);
-        const hasHiddenMessages = (0, hooks_1.useCallback)(() => {
-            return deferredComponentMessages.length !== 0;
-        }, [deferredComponentMessages]);
-        const showHiddenMessages = (0, hooks_1.useCallback)(() => {
-            setComponentMessages([...componentMessages, ...deferredComponentMessages]);
-            setDeferredComponentMessages([]);
-        }, [componentMessages, deferredComponentMessages]);
-        (0, hooks_1.useEffect)(() => {
-            if (prevMessagesCustomPropRef.current === messagesCustomProp) {
-                return;
-            }
-            prevMessagesCustomPropRef.current = messagesCustomProp;
-            if ((0, utils_1.isShallowEqual)(messagesCustom, messagesCustomProp)) {
-                return;
-            }
-            setMessagesCustom(messagesCustomProp);
-        }, [messagesCustom, messagesCustomProp]);
-        return (0, hooks_1.useMemo)(() => ({
-            componentMessages,
-            deferredComponentMessages,
-            messagesCustom,
-            visibleMessages: [...messagesCustom, ...componentMessages],
-            addComponentMessage,
-            addDeferredComponentMessage,
-            clearAllComponentMessages,
-            clearAllMessages,
-            clearDeferredComponentMessages,
-            hasCustomErrorMessages,
-            hasHiddenMessages,
-            hasNoErrorMessages,
-            setComponentMessages,
-            setDeferredComponentMessages,
-            showHiddenMessages
-        }), [
-            componentMessages,
-            deferredComponentMessages,
-            messagesCustom,
-            hasCustomErrorMessages,
-            hasHiddenMessages,
-            hasNoErrorMessages,
-            showHiddenMessages
-        ]);
-    }
-    exports.useComponentMessaging = useComponentMessaging;
-});