@oracle/oraclejet-core-pack 14.0.0

package/oj-c/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/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/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/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/editable-value/UNSAFE_useValue/useValue.js

@@ -0,0 +1,42 @@
+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 === null || onRawValueChanged === void 0 ? void 0 : onRawValueChanged(displayValue);
+            }
+        }, []);
+        const [transientValue, setTransientValue] = (0, UNSAFE_useUncontrolledState_1.useUncontrolledState)(valueProp, onTransientValueChanged);
+        (0, hooks_1.useEffect)(() => {
+            if (valueProp !== undefined) {
+                onTransientValueChanged === null || onTransientValueChanged === void 0 ? void 0 : 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,
+            setTransientValue,
+            setValue,
+            refreshDisplayValue: (0, hooks_1.useCallback)(() => {
+                setDisplayValue(format(value));
+            }, [value, format])
+        };
+    }
+    exports.useValue = useValue;
+});

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

@@ -0,0 +1,27 @@
+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));
+        }, []);
+        (0, hooks_1.useEffect)(() => {
+            if (previousValueRef.current === value) {
+                return;
+            }
+            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));
+                }
+            }
+        }, [value, valueState, format]);
+    }
+    exports.useValueLifecycle = useValueLifecycle;
+});

package/oj-c/editable-value/component.json

@@ -0,0 +1,9 @@
+{
+  "name": "editable-value",
+  "version": "1.0.0",
+  "jetVersion": "^13.0.0",
+  "type": "resource",
+  "displayName": "Editable Value",
+  "description": "The common resources including hooks and utils that will be used by the form components.",
+  "pack": "oj-c"
+}

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

@@ -0,0 +1,31 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isShallowEqual = exports.normalizeValue = exports.treatNull = 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 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/file-picker/__webdriver__/FilePickerWebElement.js

@@ -0,0 +1,32 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+exports.__esModule = true;
+exports.FilePickerWebElement = void 0;
+var FilePickerWebElementBase_1 = require("./FilePickerWebElementBase");
+/**
+ * The component WebElement for [oj-c-file-picker](../../../oj-c/docs/oj.FilePicker.html).
+ * Do not instantiate this class directly, instead, use
+ * [findFilePicker](../modules.html#findFilePicker).
+ */
+var FilePickerWebElement = /** @class */ (function (_super) {
+    __extends(FilePickerWebElement, _super);
+    function FilePickerWebElement() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return FilePickerWebElement;
+}(FilePickerWebElementBase_1.FilePickerWebElementBase));
+exports.FilePickerWebElement = FilePickerWebElement;