@oracle/oraclejet-core-pack 14.0.0

package/oj-c/min/editable-value/UNSAFE_useConverterLifecycle/useConverterLifecycle.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="ojconverter" />
+import Converter from 'ojs/ojconverter';
+import { ValidationState } from '../UNSAFE_useValidators/useValidators';
+declare type UseConverterLifecycleProps<V> = {
+    converter?: Converter<V>;
+    validationState: ValidationState<V>;
+    refreshDisplayValue: () => void;
+    runFullValidationAndUpdateValue: () => Promise<void>;
+};
+export declare function useConverterLifecycle<V>({ converter, validationState, refreshDisplayValue, runFullValidationAndUpdateValue }: UseConverterLifecycleProps<V>): void;
+export {};

package/oj-c/min/editable-value/UNSAFE_useConverterLifecycle/useConverterLifecycle.js

@@ -0,0 +1,26 @@
+define(["require", "exports", "preact/hooks"], function (require, exports, hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useConverterLifecycle = void 0;
+    function useConverterLifecycle({ converter, validationState, refreshDisplayValue, runFullValidationAndUpdateValue }) {
+        const prevConverterRef = (0, hooks_1.useRef)(converter);
+        (0, hooks_1.useEffect)(() => {
+            if (prevConverterRef.current === converter) {
+                return;
+            }
+            prevConverterRef.current = converter;
+            const { valid } = validationState;
+            switch (valid) {
+                case 'invalidShown':
+                    runFullValidationAndUpdateValue();
+                    break;
+                case 'valid':
+                case 'invalidHidden':
+                default:
+                    refreshDisplayValue();
+                    break;
+            }
+        }, [converter, validationState, refreshDisplayValue, runFullValidationAndUpdateValue]);
+    }
+    exports.useConverterLifecycle = useConverterLifecycle;
+});

package/oj-c/min/editable-value/UNSAFE_useDeferredValidators/useDeferredValidators.d.ts

@@ -0,0 +1,8 @@
+import { ValidatorLike } from '../UNSAFE_useValidators/useValidators';
+declare type UseDeferredValidatorsProps = {
+    labelHint?: string;
+    required?: boolean;
+    requiredMessageDetail?: string;
+};
+export declare function useDeferredValidators<V>({ labelHint, required, requiredMessageDetail }: UseDeferredValidatorsProps): ValidatorLike<V>[];
+export {};

package/oj-c/min/editable-value/UNSAFE_useDeferredValidators/useDeferredValidators.js

@@ -0,0 +1,22 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "ojs/ojvalidator-required", "preact/hooks"], function (require, exports, ojvalidator_required_1, hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useDeferredValidators = void 0;
+    ojvalidator_required_1 = __importDefault(ojvalidator_required_1);
+    function useDeferredValidators({ labelHint, required, requiredMessageDetail }) {
+        const requiredValidator = (0, hooks_1.useMemo)(() => {
+            if (required) {
+                return new ojvalidator_required_1.default({
+                    label: labelHint,
+                    messageDetail: requiredMessageDetail
+                });
+            }
+            return null;
+        }, [required]);
+        return (0, hooks_1.useMemo)(() => [requiredValidator].filter(Boolean), [requiredValidator]);
+    }
+    exports.useDeferredValidators = useDeferredValidators;
+});

package/oj-c/min/editable-value/UNSAFE_useEditableValue/useEditableValue.d.ts

@@ -0,0 +1,47 @@
+import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import { UseComponentMessagingProps } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+import { ConverterErrorSymbol, UseConverterProps } from '../UNSAFE_useConverter/useConverter';
+import { UseValidatorsProps, ValidationResult } from '../UNSAFE_useValidators/useValidators';
+import { UseValueProps, ValueState } from '../UNSAFE_useValue/useValue';
+import { ValidatorLike } from '../UNSAFE_useValidators/useValidators';
+declare type PickedComponentMessagingProps = Pick<UseComponentMessagingProps, 'messagesCustom' | 'onMessagesCustomChanged'>;
+declare type PickedConverterProps<V> = Pick<UseConverterProps<V>, 'converter'>;
+declare type PickedValidatorsProps<V> = Pick<UseValidatorsProps<V>, 'validators' | 'addBusyState' | 'onValidChanged'>;
+declare type PickedValueProps<V> = Pick<UseValueProps<V>, 'onRawValueChanged' | 'onTransientValueChanged' | 'onValueChanged' | 'value'>;
+declare type AriaProps = {
+    ariaDescribedBy?: string;
+};
+export declare type UseEditableValueProps<V> = PickedComponentMessagingProps & PickedConverterProps<V> & PickedValidatorsProps<V> & PickedValueProps<V> & AriaProps & {
+    displayOptions?: {
+        messages?: 'display' | 'none';
+    };
+    implicitComponentValidator?: ValidatorLike<V>;
+    labelHint?: string;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    shouldNormalizeValueOnCommit?: boolean;
+    wrapValueState?: (valueState: ValueState<V>) => ValueState<V>;
+};
+export declare function useEditableValue<V>({ ariaDescribedBy, converter, displayOptions, implicitComponentValidator, labelHint, messagesCustom, required, requiredMessageDetail, shouldNormalizeValueOnCommit, validators, value: valueProp, addBusyState, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, onTransientValueChanged, wrapValueState }: UseEditableValueProps<V>): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    displayValue: string;
+    setDisplayValue: import("preact/hooks").StateUpdater<string>;
+    setTransientValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<'valid' | 'invalid'>;
+        showMessages: () => void;
+    };
+    textFieldProps: {
+        messages: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        value: string;
+        ariaDescribedBy: string | undefined;
+        onCommit: ({ value }: ValueUpdateDetail<string>) => Promise<void>;
+        onInput: ({ value }: ValueUpdateDetail<string>) => void;
+    };
+    onCommitValue: (value: V, doCommitOnValid?: boolean) => Promise<ValidationResult>;
+    format: (value: V, shouldSuppressError?: boolean) => string | null | undefined;
+    normalizeAndParseValue: (value: string) => typeof ConverterErrorSymbol | V | null;
+};
+export {};

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

@@ -0,0 +1,154 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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, displayOptions, implicitComponentValidator, labelHint, messagesCustom, 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
+        });
+        (0, useConverterLifecycle_1.useConverterLifecycle)({
+            converter,
+            validationState,
+            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)((value, doCommitOnValid = true) => __awaiter(this, void 0, void 0, function* () {
+            const validationResult = yield validateValueOnInternalChange(value);
+            if (validationResult === useValidators_1.ValidationResult.VALID && doCommitOnValid) {
+                setValue(value);
+            }
+            return validationResult;
+        }), [validateValueOnInternalChange]);
+        const onCommit = (0, hooks_1.useCallback)(({ value }) => __awaiter(this, void 0, void 0, function* () {
+            const parsedValueOrSymbol = normalizeAndParseValue(value);
+            if (parsedValueOrSymbol === useConverter_1.ConverterErrorSymbol) {
+                return;
+            }
+            const parsedValue = parsedValueOrSymbol;
+            const validationResult = yield onCommitValue(parsedValue);
+            if (validationResult === useValidators_1.ValidationResult.VALID) {
+                setDisplayValue(format(parsedValue));
+            }
+        }), [format, onCommitValue, normalizeAndParseValue]);
+        const onInput = (0, hooks_1.useCallback)(({ value }) => {
+            setDisplayValue(value !== null && value !== void 0 ? value : '');
+        }, []);
+        const reset = (0, hooks_1.useCallback)(() => {
+            clearAllMessages();
+            validateValueOnExternalChange(value);
+            refreshDisplayValue();
+        }, [value, clearAllMessages, refreshDisplayValue, validateValueOnExternalChange]);
+        const validate = (0, hooks_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+            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 === null || addBusyState === void 0 ? void 0 : addBusyState('running component method validate');
+            const validateResult = yield fullValidate(newValue);
+            resolver === null || resolver === void 0 ? void 0 : resolver();
+            if (validateResult) {
+                if (newValue !== value) {
+                    setValueAfterValidation(newValue);
+                }
+                return 'valid';
+            }
+            return 'invalid';
+        }), [validationState, valueState, addBusyState, normalizeAndParseValue]);
+        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 === null || displayOptions === void 0 ? void 0 : displayOptions.messages) !== 'none' ? visibleMessages : undefined,
+                value: displayValue,
+                ariaDescribedBy,
+                onCommit,
+                onInput
+            },
+            onCommitValue,
+            format,
+            normalizeAndParseValue
+        };
+    }
+    exports.useEditableValue = useEditableValue;
+});

package/oj-c/min/editable-value/UNSAFE_useStaleIdentity/useStaleIdentity.d.ts

@@ -0,0 +1,5 @@
+export declare function useStaleIdentity(): {
+    setStaleIdentity: (id: `use${string}`) => {
+        isStale: () => boolean;
+    };
+};

package/oj-c/min/editable-value/UNSAFE_useStaleIdentity/useStaleIdentity.js

@@ -0,0 +1,17 @@
+define(["require", "exports", "preact/hooks"], function (require, exports, hooks_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useStaleIdentity = void 0;
+    function useStaleIdentity() {
+        const staleIdentityMap = (0, hooks_1.useRef)(new Map());
+        const setStaleIdentity = (0, hooks_1.useCallback)((id) => {
+            const localStaleIdentity = Symbol();
+            staleIdentityMap.current.set(id, localStaleIdentity);
+            return {
+                isStale: () => localStaleIdentity !== staleIdentityMap.current.get(id)
+            };
+        }, []);
+        return { setStaleIdentity };
+    }
+    exports.useStaleIdentity = useStaleIdentity;
+});

package/oj-c/min/editable-value/UNSAFE_useValidationLifecycle/useValidationLifecycle.d.ts

@@ -0,0 +1,15 @@
+import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+import { ConverterErrorSymbol } from '../UNSAFE_useConverter/useConverter';
+import { UseValidatorsProps, ValidationState, ValidState } from '../UNSAFE_useValidators/useValidators';
+declare type PickedUseValidatorsProps<V> = Pick<UseValidatorsProps<V>, 'deferredValidators' | 'validators'>;
+declare type UseValidationLifecycleProps<V> = PickedUseValidatorsProps<V> & {
+    componentMessagingState: ComponentMessagingState;
+    validationState: ValidationState<V>;
+    addBusyState?: (desc?: string) => () => void;
+    getValueForValidation: (valid: ValidState) => V | typeof ConverterErrorSymbol;
+    setValueAfterValidation: (value: V) => void;
+};
+export declare function useValidationLifecycle<V>({ componentMessagingState, deferredValidators, validationState, validators, getValueForValidation, setValueAfterValidation }: UseValidationLifecycleProps<V>): {
+    runFullValidationAndUpdateValue: () => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,118 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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, deferredValidators, 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 runFullValidationAndUpdateValue = (0, hooks_1.useCallback)(() => __awaiter(this, void 0, void 0, function* () {
+            const { valid, validateValueOnInternalChange } = validationState;
+            const value = getValueForValidation(valid);
+            if (value === useConverter_1.ConverterErrorSymbol) {
+                return;
+            }
+            const validationResult = yield validateValueOnInternalChange(value, {
+                doNotClearMessagesCustom: true
+            });
+            if (validationResult === useValidators_1.ValidationResult.VALID) {
+                setValueAfterValidation(value);
+            }
+        }), [validationState, getValueForValidation, setValueAfterValidation]);
+        (0, hooks_1.useEffect)(() => {
+            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');
+            }
+        }, []);
+        (0, hooks_1.useEffect)(() => {
+            if (prevDeferredValidatorsRef.current === deferredValidators) {
+                return;
+            }
+            const { valid, deferredValidate, setValid } = validationState;
+            const { clearDeferredComponentMessages, setDeferredComponentMessages } = componentMessagingState;
+            prevDeferredValidatorsRef.current = deferredValidators;
+            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;
+            }
+        }, [
+            deferredValidators,
+            componentMessagingState,
+            validationState,
+            getValueForValidation,
+            runFullValidationAndUpdateValue
+        ]);
+        (0, hooks_1.useEffect)(() => {
+            if (prevValidatorsRef.current === validators) {
+                return;
+            }
+            prevValidatorsRef.current = validators;
+            switch (validationState.valid) {
+                case 'invalidShown':
+                    runFullValidationAndUpdateValue();
+                    break;
+            }
+        }, [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/min/editable-value/UNSAFE_useValidators/useValidators.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="ojvalidator" />
+/// <reference types="ojvalidator-async" />
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+import { StateUpdater } from 'preact/hooks';
+import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+export declare const ValidationResult: {
+    readonly VALID: "VALID";
+    readonly INVALID: "INVALID";
+    readonly STALE: "STALE";
+};
+export declare type ValidationResult = typeof ValidationResult[keyof typeof ValidationResult];
+export declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+export declare type ValidatorLike<V> = Validator<V> | AsyncValidator<V>;
+export declare type ValidationOptions = {
+    doNotClearMessagesCustom?: boolean;
+};
+export declare type ValidationState<V> = {
+    valid: ValidState;
+    setValid: StateUpdater<ValidState>;
+    deferredValidate: (value: V) => void | ComponentMessageItem[];
+    fullValidate: (value: V, options?: ValidationOptions) => Promise<boolean>;
+    validateValueOnInternalChange: (value: V, options?: ValidationOptions) => Promise<ValidationResult>;
+    validateValueOnExternalChange: (value: V) => ValidationResult;
+};
+export declare type UseValidatorsProps<V> = {
+    componentMessagingState: ComponentMessagingState;
+    defaultValidState?: ValidState;
+    deferredValidators?: ValidatorLike<V>[];
+    validators?: ValidatorLike<V>[];
+    addBusyState?: (desc?: string) => () => void;
+    onValidChanged?: (valid: ValidState) => void;
+};
+export declare function useValidators<V>({ componentMessagingState, defaultValidState, deferredValidators, validators, addBusyState, onValidChanged }: UseValidatorsProps<V>): ValidationState<V>;

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

@@ -0,0 +1,153 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 === null || onValidChanged === void 0 ? void 0 : onValidChanged(defaultValidState);
+            }
+        }, []);
+        const fullValidate = (0, hooks_1.useCallback)((value, options = {}) => __awaiter(this, void 0, void 0, function* () {
+            const { addComponentMessage, clearAllComponentMessages, clearAllMessages, hasCustomErrorMessages, setComponentMessages } = componentMessagingState;
+            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;
+            }
+            const errors = [];
+            const maybeErrorsPromise = [];
+            for (const validator of [...deferredValidators, ...validators]) {
+                try {
+                    const validateResult = validator.validate(value);
+                    if (validateResult instanceof Promise) {
+                        maybeErrorsPromise.push(validateResult.then(() => { }, (error) => (0, utils_1.createMessageFromError)(error)));
+                    }
+                }
+                catch (error) {
+                    errors.push((0, utils_1.createMessageFromError)(error));
+                }
+            }
+            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 === null || addBusyState === void 0 ? void 0 : addBusyState('running validation');
+            const { isStale } = setStaleIdentity('useValidators-validate');
+            let hasAsyncError = false;
+            for (const asyncValidationResult of maybeErrorsPromise) {
+                const maybeValidationError = yield asyncValidationResult;
+                if (maybeValidationError && !isStale()) {
+                    addComponentMessage(maybeValidationError);
+                    setValid('invalidShown');
+                    hasAsyncError = true;
+                }
+            }
+            if (!hasSyncError && !hasAsyncError && !isStale()) {
+                if (hadCustomErrorMessages && doNotClearMessagesCustom) {
+                    setValid('invalidShown');
+                }
+                else {
+                    setValid('valid');
+                }
+            }
+            resolver === null || resolver === void 0 ? void 0 : resolver();
+            return !hasSyncError && !hasAsyncError;
+        }), [componentMessagingState, 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)((value, options = {}) => __awaiter(this, void 0, void 0, function* () {
+            const { isStale } = setStaleIdentity('useValidationLifeCycle-validateValueOnInternalChange');
+            const resolver = addBusyState === null || addBusyState === void 0 ? void 0 : addBusyState('running validateValueOnInternalChange');
+            const validationResult = yield fullValidate(value, options);
+            resolver === null || resolver === void 0 ? void 0 : 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/min/editable-value/UNSAFE_useValue/useValue.d.ts

@@ -0,0 +1,23 @@
+import { StateUpdater } from 'preact/hooks';
+import { ConverterErrorSymbol } from '../UNSAFE_useConverter/useConverter';
+import { ValidState } from '../UNSAFE_useValidators/useValidators';
+export declare type ValueState<V> = {
+    displayValue: string;
+    transientValue: V;
+    value: V;
+    getValueForValidation: (valid: ValidState) => V | typeof ConverterErrorSymbol;
+    setValueAfterValidation: (value: V) => void;
+    setDisplayValue: StateUpdater<string>;
+    setTransientValue: StateUpdater<V>;
+    setValue: StateUpdater<V>;
+    refreshDisplayValue: () => void;
+};
+export declare type UseValueProps<V> = {
+    value?: V;
+    format: (value: V, shouldSuppressError?: boolean) => string;
+    parse: (value: string) => V | typeof ConverterErrorSymbol;
+    onRawValueChanged?: (rawValue: string) => void;
+    onTransientValueChanged?: (transientValue: V | null | undefined) => void;
+    onValueChanged?: (value: V | null | undefined) => void;
+};
+export declare function useValue<V>({ value: valueProp, format, parse, onRawValueChanged, onTransientValueChanged, onValueChanged }: UseValueProps<V>): ValueState<V>;