@oracle/oraclejet-core-pack 16.1.3 → 17.0.0

package/oj-c/types/hooks/UNSAFE_useEditableValue/reducer.d.ts

@@ -0,0 +1,106 @@
+import type { Dispatch } from 'preact/hooks';
+import type { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import type { Optional, ValidState } from './types';
+import type { Converter } from './types';
+import type Validator = require('ojs/ojvalidator');
+import type AsyncValidator = require('ojs/ojvalidator-async');
+export type Callbacks<V, DV> = {
+    onMessagesCustomChanged?: (messagesCustom?: ComponentMessageItem[]) => void;
+    onRawValueChanged?: (rawValue: DV) => void;
+    onTransientValueChanged?: (transientValue: V) => void;
+    onValidChanged?: (valid: ValidState) => void;
+    onValueChanged?: (value: V) => void;
+};
+type UpdateDisplayValueAction<DV> = {
+    type: 'UPDATE_DISPLAY_VALUE';
+    payload: DV;
+};
+type UpdateValueAction<V> = {
+    type: 'UPDATE_VALUE';
+    payload: Optional<V>;
+};
+type UpdateValidAction = {
+    type: 'UPDATE_VALID';
+    payload: ValidState;
+};
+type UpdateComponentMessagesAction = {
+    type: 'UPDATE_COMPONENT_MESSAGES';
+    payload: ComponentMessageItem[];
+};
+type UpdateCustomMessagesAction = {
+    type: 'UPDATE_CUSTOM_MESSAGES';
+    payload: ComponentMessageItem[];
+};
+type UpdateHiddenMessagesAction = {
+    type: 'UPDATE_HIDDEN_MESSAGES';
+    payload: ComponentMessageItem[];
+};
+type ShowHiddenMessagesAction = {
+    type: 'SHOW_HIDDEN_MESSAGES';
+    payload?: never;
+};
+type ClearAllMessagesAction = {
+    type: 'CLEAR_ALL_MESSAGES';
+    payload?: never;
+};
+type AddComponentMessageAction = {
+    type: 'ADD_COMPONENT_MESSAGE';
+    payload: ComponentMessageItem;
+};
+type UpdatePreviousConverterAction<V, DV> = {
+    type: 'UPDATE_PREVIOUS_CONVERTER';
+    payload?: Converter<V, DV>;
+};
+type UpdatePreviousDeferredValidatorsAction<V> = {
+    type: 'UPDATE_PREVIOUS_DEFERRED_VALIDATORS';
+    payload?: Validator<V>[];
+};
+type UpdatePreviousDisabledAction = {
+    type: 'UPDATE_PREVIOUS_DISABLED';
+    payload?: boolean;
+};
+type UpdatePreviousReadonlyAction = {
+    type: 'UPDATE_PREVIOUS_READONLY';
+    payload?: boolean;
+};
+type UpdatePreviousValidatorsAction<V> = {
+    type: 'UPDATE_PREVIOUS_VALIDATORS';
+    payload?: (AsyncValidator<V> | Validator<V>)[];
+};
+type UpdatePreviousValueAction<V> = {
+    type: 'UPDATE_PREVIOUS_VALUE';
+    payload: Optional<V>;
+};
+type Action<V, DV> = UpdateDisplayValueAction<DV> | UpdateValueAction<V> | UpdateValidAction | UpdateComponentMessagesAction | UpdateCustomMessagesAction | UpdateHiddenMessagesAction | ClearAllMessagesAction | AddComponentMessageAction | ShowHiddenMessagesAction | UpdatePreviousConverterAction<V, DV> | UpdatePreviousDeferredValidatorsAction<V> | UpdatePreviousDisabledAction | UpdatePreviousReadonlyAction | UpdatePreviousValidatorsAction<V> | UpdatePreviousValueAction<V>;
+type State<V, DV> = Readonly<{
+    customMessages?: ComponentMessageItem[];
+    componentMessages: ComponentMessageItem[];
+    hiddenMessages: ComponentMessageItem[];
+    shownMessages: ComponentMessageItem[];
+    displayValue?: DV;
+    value?: Optional<V>;
+    valid?: ValidState;
+    previousConverter?: Converter<V, DV>;
+    previousDeferredValidators?: Validator<V>[];
+    previousDisabled?: boolean;
+    previousReadonly?: boolean;
+    previousValidators?: (AsyncValidator<V> | Validator<V>)[];
+    previousValue?: Optional<V>;
+}>;
+declare function reducer<V, DV>(state: State<V, DV>, action: Action<V, DV>): State<V, DV>;
+declare function updateDisplayValue<V, DV>(dispatch: Dispatch<Action<V, DV>>, displayValue: DV, { onRawValueChanged }: Callbacks<V, DV>): void;
+declare function updateValidStatus<V, DV>(dispatch: Dispatch<Action<V, DV>>, state: ValidState, { onValidChanged }: Callbacks<V, DV>): void;
+declare function updateValue<V, DV>(dispatch: Dispatch<Action<V, DV>>, value: V, { onValueChanged }: Callbacks<V, DV>): void;
+declare function updateComponentMessages<V, DV>(dispatch: Dispatch<Action<V, DV>>, messages: ComponentMessageItem[]): void;
+declare function updateHiddenMessages<V, DV>(dispatch: Dispatch<Action<V, DV>>, messages: ComponentMessageItem[]): void;
+declare function updateCustomMessages<V, DV>(dispatch: Dispatch<Action<V, DV>>, messages: ComponentMessageItem[]): void;
+declare function updatePreviousValue<V, DV>(dispatch: Dispatch<Action<V, DV>>, value: V): void;
+declare function updatePreviousConverter<V, DV>(dispatch: Dispatch<Action<V, DV>>, converter?: Converter<V, DV>): void;
+declare function updatePreviousDeferredValidators<V, DV>(dispatch: Dispatch<Action<V, DV>>, validators?: Validator<V>[]): void;
+declare function updatePreviousDisabled<V, DV>(dispatch: Dispatch<Action<V, DV>>, disabled?: boolean): void;
+declare function updatePreviousReadonly<V, DV>(dispatch: Dispatch<Action<V, DV>>, readonly?: boolean): void;
+declare function updatePreviousValidators<V, DV>(dispatch: Dispatch<Action<V, DV>>, validators?: (AsyncValidator<V> | Validator<V>)[]): void;
+declare function clearAllMessages<V, DV>(dispatch: Dispatch<Action<V, DV>>, _value: any, { onMessagesCustomChanged }: Callbacks<V, DV>): void;
+declare function showHiddenMessages<V, DV>(dispatch: Dispatch<Action<V, DV>>): void;
+declare function addComponentMessage<V, DV>(dispatch: Dispatch<Action<V, DV>>, message: ComponentMessageItem): void;
+export { reducer, Action, State, addComponentMessage, clearAllMessages, showHiddenMessages, updateComponentMessages, updateCustomMessages, updateDisplayValue, updateHiddenMessages, updatePreviousConverter, updatePreviousDeferredValidators, updatePreviousDisabled, updatePreviousReadonly, updatePreviousValidators, updatePreviousValue, updateValidStatus, updateValue };

package/oj-c/types/hooks/UNSAFE_useEditableValue/types.d.ts

@@ -0,0 +1,7 @@
+type Converter<V, DV> = {
+    format(value: V): DV;
+    parse(displayValue: DV): V;
+};
+type Optional<V> = V | null | undefined;
+type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+export type { Converter, Optional, ValidState };

package/oj-c/types/hooks/UNSAFE_useEditableValue/useEditableValue.d.ts

@@ -0,0 +1,43 @@
+import type { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import type { Optional, ValidState } from './types';
+import type { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import type { Converter } from './types';
+import type Validator = require('ojs/ojvalidator');
+import type AsyncValidator = require('ojs/ojvalidator-async');
+type UseEditableValueProps<V, DV> = {
+    addBusyState?: (desc?: string) => () => void;
+    ariaDescribedBy?: string;
+    converter?: Converter<V, DV>;
+    defaultDisplayValue: DV;
+    deferredValidators?: Validator<V>[];
+    disabled?: boolean;
+    displayOptions?: {
+        messages?: 'display' | 'none';
+    };
+    messagesCustom?: ComponentMessageItem[];
+    onMessagesCustomChanged?: (messagesCustom?: ComponentMessageItem[]) => void;
+    onRawValueChanged?: (rawValue: DV) => void;
+    onTransientValueChanged?: (transientValue: V) => void;
+    onValidChanged?: (valid: ValidState) => void;
+    onValueChanged?: (value: V) => void;
+    readonly?: boolean;
+    validators?: (AsyncValidator<V> | Validator<V>)[];
+    value?: V;
+};
+export declare function useEditableValue<V = string, DV = V>({ addBusyState, ariaDescribedBy, converter, defaultDisplayValue, deferredValidators, disabled, displayOptions, messagesCustom, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, readonly, validators, value }: UseEditableValueProps<V, DV>): {
+    value: Optional<V>;
+    displayValue: DV | undefined;
+    methods: {
+        reset: () => void;
+        showMessages: () => void;
+        validate: () => Promise<'valid' | 'invalid'>;
+    };
+    textFieldProps: {
+        'aria-describedby': string | undefined;
+        messages: ComponentMessageItem[] | undefined;
+        onCommit: ({ value }: ValueUpdateDetail<DV>) => Promise<void>;
+        onInput: ({ value }: ValueUpdateDetail<DV>) => void;
+        value: DV | undefined;
+    };
+};
+export {};

package/oj-c/types/hooks/UNSAFE_useEditableValue/utils.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import type { ConverterError, ValidatorError } from 'ojs/ojvalidation-error';
+declare const createMessageFromError: (error: Error | ValidatorError | ConverterError) => ComponentMessageItem;
+declare const treatNull: <T>(value?: T | null, defaultValue?: T) => T | undefined;
+declare const normalizeValue: <T>(value?: T) => T | null | undefined;
+declare const isShallowEqual: <T>(a: T[], b: T[]) => boolean;
+declare const hasErrorMessages: (messages?: ComponentMessageItem[]) => boolean;
+export { createMessageFromError, hasErrorMessages, isShallowEqual, normalizeValue, treatNull };

package/oj-c/types/hooks/UNSAFE_useEditableValue/validationUtils.d.ts

@@ -0,0 +1,27 @@
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import type AsyncValidator = require('ojs/ojvalidator-async');
+import type Validator = require('ojs/ojvalidator');
+type ValidationSuccess = {
+    result: 'success';
+};
+type ValidationFailure = {
+    result: 'failure';
+    errors: ComponentMessageItem[];
+};
+type ValidationResult = ValidationFailure | ValidationSuccess;
+type ValidatorLike<V> = Validator<V> | AsyncValidator<V>;
+type AsyncValidationResult = {
+    errors: ComponentMessageItem[];
+    maybeErrorPromises: Promise<void | ComponentMessageItem>[];
+};
+type ValidateSyncParams<V> = {
+    value: V;
+    validators: Validator<V>[];
+};
+type ValidateAsyncParams<V> = {
+    value: V;
+    validators: ValidatorLike<V>[];
+};
+declare function validateSync<V>({ validators, value }: ValidateSyncParams<V>): ValidationResult;
+declare function validateAsync<V>({ validators, value }: ValidateAsyncParams<V>): AsyncValidationResult;
+export { validateAsync, validateSync };

package/oj-c/types/hooks/UNSAFE_useMergedFormContext/useMergedFormContext.d.ts

@@ -0,0 +1,16 @@
+import { ComponentProps } from 'preact';
+import { FormContextProps } from '@oracle/oraclejet-preact/hooks/UNSAFE_useFormContext';
+import type { TextArea } from 'oj-c/text-area';
+type TextAreaProps = ComponentProps<typeof TextArea>;
+type Props = {
+    propContainerReadonly: TextAreaProps['containerReadonly'];
+    propLabelWrapping: TextAreaProps['labelWrapping'];
+    propReadonly: TextAreaProps['readonly'];
+    propUserAssistanceDensity: TextAreaProps['userAssistanceDensity'];
+};
+export declare function useMergedFormContext({ propContainerReadonly, propLabelWrapping, propReadonly, propUserAssistanceDensity }: Props): {
+    containerProps: FormContextProps;
+    readonlyValue: boolean | undefined;
+    uadValue: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+};
+export {};

package/oj-c/types/hooks/UNSAFE_useVisBusyState/useVisBusyState.d.ts

@@ -0,0 +1 @@
+export declare function useVisBusyState(rootRef: preact.RefObject<HTMLElement>, baseDescription: string): () => () => void;

package/oj-c/types/input-date-mask/input-date-mask.d.ts

@@ -37,9 +37,9 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
     validators?: (AsyncValidator<DateISOStr> | Validator<DateISOStr>)[] | null;
     value?: DateISOStr | null;
     onMessagesCustomChanged?: PropertyChanged<PreactInputDateMaskProps['messages']>;
-    onRawValueChanged?: ReadOnlyPropertyChanged<CalendarDate>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<CalendarDate | undefined>;
     onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
-    onValueChanged?: PropertyChanged<string>;
+    onValueChanged?: PropertyChanged<string | null>;
 };
 type InputDateMaskHandle = {
     blur: () => void;
@@ -48,7 +48,7 @@ type InputDateMaskHandle = {
     reset: () => void;
     validate: () => Promise<'valid' | 'invalid'>;
 };
-declare const InputDateMaskImpl: ({ columnSpan, disabled, displayOptions, help, helpHints, messagesCustom, readonly, required, userAssistanceDensity, validators, value, ...otherProps }: Props, ref: Ref<InputDateMaskHandle>) => import("preact").JSX.Element;
+declare const InputDateMaskImpl: ({ columnSpan, containerReadonly: propContainerReadonly, disabled, displayOptions, help, helpHints, labelWrapping: propLabelWrapping, messagesCustom, readonly: propReadonly, required, userAssistanceDensity: propUserAssistanceDensity, validators, value, ...otherProps }: Props, ref: Ref<InputDateMaskHandle>) => import("preact").JSX.Element;
 export declare const InputDateMask: ComponentType<ExtendGlobalProps<ComponentProps<typeof InputDateMaskImpl>>>;
 export type InputDateMaskProps = Props;
 export {};

package/oj-c/types/input-date-mask/useInputDateMaskPreact.d.ts

@@ -3,17 +3,16 @@ import type { CalendarDate } from '@oracle/oraclejet-preact/UNSAFE_InputDateMask
 import type { InputDateMask } from 'oj-c/input-date-mask';
 type InputDateMaskProps = ComponentProps<typeof InputDateMask>;
 export declare function useInputDateMaskPreact({ dateRangeOverflowMessageDetail, dateRangeUnderflowMessageDetail, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, max, messagesCustom, min, readonly, required, requiredMessageDetail, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: InputDateMaskProps, addBusyState?: (desc?: string) => () => void): {
-    value: string | undefined;
-    setValue: import("preact/hooks").StateUpdater<string | undefined>;
     methods: {
         reset: () => void;
-        validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
+        validate: () => Promise<"invalid" | "valid">;
     };
-    inputDateMaskProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    inputDateMaskProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
+        endContent?: import("preact").ComponentChildren;
         granularity?: "day" | "month" | undefined;
         helpSourceLink?: string | undefined;
         helpSourceText?: string | undefined;
@@ -24,6 +23,7 @@ export declare function useInputDateMaskPreact({ dateRangeOverflowMessageDetail,
         label: string;
         labelEdge?: "none" | "start" | "top" | "inside" | undefined;
         labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        mainFieldRef?: import("preact").RefObject<HTMLDivElement> | undefined;
         masks?: import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").DatePlaceholders | undefined;
         messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
         textAlign?: "end" | "start" | "right" | undefined;
@@ -32,8 +32,9 @@ export declare function useInputDateMaskPreact({ dateRangeOverflowMessageDetail,
         variant?: "default" | "embedded" | undefined;
         onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<CalendarDate>) => void) | undefined;
         onInput: (detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<CalendarDate>) => void;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };
+export declare const getMasksFromDatePatternPreferences: () => import("@oracle/oraclejet-preact/UNSAFE_InputDateMask").DatePlaceholders | undefined;
 export {};

package/oj-c/types/input-date-picker/DateRangeValidator.d.ts

@@ -0,0 +1,31 @@
+import type { BundleType } from '@oracle/oraclejet-preact/resources/nls/bundle';
+import type { CalendarDateRequired } from '@oracle/oraclejet-preact/utils/UNSAFE_calendarDateUtils';
+import { FormatObj } from '@oracle/oraclejet-preact/UNSAFE_IntlFormatParse';
+import type { CalendarDateConverter } from 'oj-c/input-date-mask/CalendarDateConverter';
+import type Validator = require('ojs/ojvalidator');
+export type OverflowMessageDetailParameters = {
+    value: string;
+    max: string;
+};
+export type UnderflowMessageDetailParameters = {
+    value: string;
+    min: string;
+};
+type MessageDetailFn<T> = (p: T) => string;
+export type DateRangeValidatorOptions = {
+    converter: CalendarDateConverter;
+    dateRangeOverflowMessageDetail?: MessageDetailFn<OverflowMessageDetailParameters>;
+    dateRangeUnderflowMessageDetail?: MessageDetailFn<UnderflowMessageDetailParameters>;
+    defaultRangeOverflowMessageDetailFn: BundleType['inputDatePicker_dateRangeOverflowMessageDetail'];
+    defaultRangeUnderflowMessageDetailFn: BundleType['inputDatePicker_dateRangeUnderflowMessageDetail'];
+    formatObj: FormatObj<string>;
+    max?: CalendarDateRequired;
+    min?: CalendarDateRequired;
+};
+export declare class DateRangeValidator<V extends string | null = string | null> implements Validator<V> {
+    #private;
+    private options;
+    constructor(options: DateRangeValidatorOptions);
+    validate(value: V): void;
+}
+export {};

package/oj-c/types/input-date-picker/DateRestrictionValidator.d.ts

@@ -0,0 +1,25 @@
+import type { BundleType } from '@oracle/oraclejet-preact/resources/nls/bundle';
+import type { CalendarDateConverter } from 'oj-c/input-date-mask/CalendarDateConverter';
+import type { ComponentProps } from 'preact';
+import type { InputDatePicker } from './input-date-picker';
+import type Validator = require('ojs/ojvalidator');
+type InputDatePickerProps = ComponentProps<typeof InputDatePicker>;
+type DayFormatterOutput = NonNullable<ReturnType<NonNullable<InputDatePickerProps['dayFormatter']>>>;
+type InvalidSelectionStates = Exclude<DayFormatterOutput['state'], 'enabled'>;
+export type RestrictionMessageDetailParameters = {
+    state: InvalidSelectionStates;
+    value: string;
+};
+export type DateRestrictionValidatorOptions = {
+    dayFormatter: NonNullable<InputDatePickerProps['dayFormatter']>;
+    dateRestrictionMessageDetail?: InputDatePickerProps['dateRestrictionMessageDetail'];
+    defaultRestrictionMessageDetail: BundleType['inputDatePicker_dateRestrictionMessageDetail'];
+    converter: CalendarDateConverter;
+};
+export declare class DateRestrictionValidator<V extends string | null = string | null> implements Validator<V> {
+    #private;
+    private options;
+    constructor(options: DateRestrictionValidatorOptions);
+    validate(value: V): void;
+}
+export {};

package/oj-c/types/input-date-picker/index.d.ts

@@ -0,0 +1,2 @@
+export { InputDatePicker } from './input-date-picker';
+export { CInputDatePickerElement } from './input-date-picker';

package/oj-c/types/input-date-picker/input-date-picker.d.ts

@@ -0,0 +1,219 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { InputDatePicker as PreactInputDatePicker } from '@oracle/oraclejet-preact/UNSAFE_InputDatePicker';
+import type { DateISOStr } from '@oracle/oraclejet-preact/UNSAFE_IntlDateTime';
+import type { CalendarDate, CalendarDateRequired } from '@oracle/oraclejet-preact/utils/UNSAFE_calendarDateUtils';
+import type { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
+import type { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import type { ValidState } from 'oj-c/hooks/UNSAFE_useEditableValue';
+import { type ExtendGlobalProps, type ObservedGlobalProps, type PropertyChanged, type ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import type { ComponentProps, ComponentType, Ref } from 'preact';
+import type { OverflowMessageDetailParameters, UnderflowMessageDetailParameters } from './DateRangeValidator';
+import type { RestrictionMessageDetailParameters } from './DateRestrictionValidator';
+import type Validator = require('ojs/ojvalidator');
+import type AsyncValidator = require('ojs/ojvalidator-async');
+import 'css!oj-c/input-date-picker/input-date-picker-styles.css';
+type PreactInputDatePickerProps = ComponentProps<typeof PreactInputDatePicker>;
+type Props = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    columnSpan?: LayoutColumnSpan;
+    containerReadonly?: boolean;
+    dateRangeOverflowMessageDetail?: (p: OverflowMessageDetailParameters) => string;
+    dateRangeUnderflowMessageDetail?: (p: UnderflowMessageDetailParameters) => string;
+    dateRestrictionMessageDetail?: (p: RestrictionMessageDetailParameters) => string;
+    dayFormatter?: (date: CalendarDateRequired) => {
+        state: 'disabled' | 'enabled' | 'restricted';
+    };
+    daysOutsideMonth?: PreactInputDatePickerProps['daysOutsideMonth'];
+    disabled?: PreactInputDatePickerProps['isDisabled'];
+    displayOptions?: Omit<DisplayOptions, 'converterHint'>;
+    help?: Help;
+    helpHints?: HelpHints;
+    labelEdge?: PreactInputDatePickerProps['labelEdge'];
+    labelHint: PreactInputDatePickerProps['label'];
+    labelStartWidth?: PreactInputDatePickerProps['labelStartWidth'];
+    labelWrapping?: 'truncate' | 'wrap';
+    max?: DateISOStr | null;
+    messagesCustom?: PreactInputDatePickerProps['messages'];
+    min?: DateISOStr | null;
+    monthAndYearPicker?: PreactInputDatePickerProps['monthAndYearPicker'];
+    readonly?: PreactInputDatePickerProps['isReadonly'];
+    required?: PreactInputDatePickerProps['isRequired'];
+    requiredMessageDetail?: string;
+    textAlign?: PreactInputDatePickerProps['textAlign'];
+    todayTimeZone?: PreactInputDatePickerProps['todayTimeZone'];
+    todayButton?: PreactInputDatePickerProps['todayButton'];
+    userAssistanceDensity?: PreactInputDatePickerProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<DateISOStr> | Validator<DateISOStr>)[] | null;
+    value?: DateISOStr | null;
+    onMessagesCustomChanged?: PropertyChanged<PreactInputDatePickerProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<CalendarDate | undefined>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<string | null>;
+};
+type InputDatePickerHandle = {
+    blur: () => void;
+    focus: () => void;
+    showMessages: () => void;
+    reset: () => void;
+    validate: () => Promise<'valid' | 'invalid'>;
+};
+declare function InputDatePickerImpl({ columnSpan, daysOutsideMonth, disabled, displayOptions, help, helpHints, messagesCustom, monthAndYearPicker, required, todayButton, validators, value, ...otherProps }: Props, ref: Ref<InputDatePickerHandle>): import("preact").JSX.Element;
+export declare const InputDatePicker: ComponentType<ExtendGlobalProps<ComponentProps<typeof InputDatePickerImpl>>>;
+export type InputDatePickerProps = Props;
+export type InputDatePickerRef = Ref<InputDatePickerHandle>;
+export {};
+export interface CInputDatePickerElement extends JetElement<CInputDatePickerElementSettableProperties>, CInputDatePickerElementSettableProperties {
+    readonly rawValue?: Parameters<Required<Props>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props>['onValidChanged']>[0];
+    addEventListener<T extends keyof CInputDatePickerElementEventMap>(type: T, listener: (this: HTMLElement, ev: CInputDatePickerElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CInputDatePickerElementSettableProperties>(property: T): CInputDatePickerElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CInputDatePickerElementSettableProperties>(property: T, value: CInputDatePickerElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CInputDatePickerElementSettableProperties>): void;
+    setProperties(properties: CInputDatePickerElementSettablePropertiesLenient): void;
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
+}
+export namespace CInputDatePickerElement {
+    type columnSpanChanged = JetElementCustomEventStrict<CInputDatePickerElement['columnSpan']>;
+    type containerReadonlyChanged = JetElementCustomEventStrict<CInputDatePickerElement['containerReadonly']>;
+    type dateRangeOverflowMessageDetailChanged = JetElementCustomEventStrict<CInputDatePickerElement['dateRangeOverflowMessageDetail']>;
+    type dateRangeUnderflowMessageDetailChanged = JetElementCustomEventStrict<CInputDatePickerElement['dateRangeUnderflowMessageDetail']>;
+    type dateRestrictionMessageDetailChanged = JetElementCustomEventStrict<CInputDatePickerElement['dateRestrictionMessageDetail']>;
+    type dayFormatterChanged = JetElementCustomEventStrict<CInputDatePickerElement['dayFormatter']>;
+    type daysOutsideMonthChanged = JetElementCustomEventStrict<CInputDatePickerElement['daysOutsideMonth']>;
+    type disabledChanged = JetElementCustomEventStrict<CInputDatePickerElement['disabled']>;
+    type displayOptionsChanged = JetElementCustomEventStrict<CInputDatePickerElement['displayOptions']>;
+    type helpChanged = JetElementCustomEventStrict<CInputDatePickerElement['help']>;
+    type helpHintsChanged = JetElementCustomEventStrict<CInputDatePickerElement['helpHints']>;
+    type labelEdgeChanged = JetElementCustomEventStrict<CInputDatePickerElement['labelEdge']>;
+    type labelHintChanged = JetElementCustomEventStrict<CInputDatePickerElement['labelHint']>;
+    type labelStartWidthChanged = JetElementCustomEventStrict<CInputDatePickerElement['labelStartWidth']>;
+    type labelWrappingChanged = JetElementCustomEventStrict<CInputDatePickerElement['labelWrapping']>;
+    type maxChanged = JetElementCustomEventStrict<CInputDatePickerElement['max']>;
+    type messagesCustomChanged = JetElementCustomEventStrict<CInputDatePickerElement['messagesCustom']>;
+    type minChanged = JetElementCustomEventStrict<CInputDatePickerElement['min']>;
+    type monthAndYearPickerChanged = JetElementCustomEventStrict<CInputDatePickerElement['monthAndYearPicker']>;
+    type rawValueChanged = JetElementCustomEventStrict<CInputDatePickerElement['rawValue']>;
+    type readonlyChanged = JetElementCustomEventStrict<CInputDatePickerElement['readonly']>;
+    type requiredChanged = JetElementCustomEventStrict<CInputDatePickerElement['required']>;
+    type requiredMessageDetailChanged = JetElementCustomEventStrict<CInputDatePickerElement['requiredMessageDetail']>;
+    type textAlignChanged = JetElementCustomEventStrict<CInputDatePickerElement['textAlign']>;
+    type todayButtonChanged = JetElementCustomEventStrict<CInputDatePickerElement['todayButton']>;
+    type todayTimeZoneChanged = JetElementCustomEventStrict<CInputDatePickerElement['todayTimeZone']>;
+    type userAssistanceDensityChanged = JetElementCustomEventStrict<CInputDatePickerElement['userAssistanceDensity']>;
+    type validChanged = JetElementCustomEventStrict<CInputDatePickerElement['valid']>;
+    type validatorsChanged = JetElementCustomEventStrict<CInputDatePickerElement['validators']>;
+    type valueChanged = JetElementCustomEventStrict<CInputDatePickerElement['value']>;
+}
+export interface CInputDatePickerElementEventMap extends HTMLElementEventMap {
+    'columnSpanChanged': JetElementCustomEventStrict<CInputDatePickerElement['columnSpan']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CInputDatePickerElement['containerReadonly']>;
+    'dateRangeOverflowMessageDetailChanged': JetElementCustomEventStrict<CInputDatePickerElement['dateRangeOverflowMessageDetail']>;
+    'dateRangeUnderflowMessageDetailChanged': JetElementCustomEventStrict<CInputDatePickerElement['dateRangeUnderflowMessageDetail']>;
+    'dateRestrictionMessageDetailChanged': JetElementCustomEventStrict<CInputDatePickerElement['dateRestrictionMessageDetail']>;
+    'dayFormatterChanged': JetElementCustomEventStrict<CInputDatePickerElement['dayFormatter']>;
+    'daysOutsideMonthChanged': JetElementCustomEventStrict<CInputDatePickerElement['daysOutsideMonth']>;
+    'disabledChanged': JetElementCustomEventStrict<CInputDatePickerElement['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CInputDatePickerElement['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CInputDatePickerElement['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CInputDatePickerElement['helpHints']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CInputDatePickerElement['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CInputDatePickerElement['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CInputDatePickerElement['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CInputDatePickerElement['labelWrapping']>;
+    'maxChanged': JetElementCustomEventStrict<CInputDatePickerElement['max']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CInputDatePickerElement['messagesCustom']>;
+    'minChanged': JetElementCustomEventStrict<CInputDatePickerElement['min']>;
+    'monthAndYearPickerChanged': JetElementCustomEventStrict<CInputDatePickerElement['monthAndYearPicker']>;
+    'rawValueChanged': JetElementCustomEventStrict<CInputDatePickerElement['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CInputDatePickerElement['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CInputDatePickerElement['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CInputDatePickerElement['requiredMessageDetail']>;
+    'textAlignChanged': JetElementCustomEventStrict<CInputDatePickerElement['textAlign']>;
+    'todayButtonChanged': JetElementCustomEventStrict<CInputDatePickerElement['todayButton']>;
+    'todayTimeZoneChanged': JetElementCustomEventStrict<CInputDatePickerElement['todayTimeZone']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CInputDatePickerElement['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CInputDatePickerElement['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CInputDatePickerElement['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CInputDatePickerElement['value']>;
+}
+export interface CInputDatePickerElementSettableProperties extends JetSettableProperties {
+    columnSpan?: Props['columnSpan'];
+    containerReadonly?: Props['containerReadonly'];
+    dateRangeOverflowMessageDetail?: Props['dateRangeOverflowMessageDetail'];
+    dateRangeUnderflowMessageDetail?: Props['dateRangeUnderflowMessageDetail'];
+    dateRestrictionMessageDetail?: Props['dateRestrictionMessageDetail'];
+    dayFormatter?: Props['dayFormatter'];
+    daysOutsideMonth?: Props['daysOutsideMonth'];
+    disabled?: Props['disabled'];
+    displayOptions?: Props['displayOptions'];
+    help?: Props['help'];
+    helpHints?: Props['helpHints'];
+    labelEdge?: Props['labelEdge'];
+    labelHint: Props['labelHint'];
+    labelStartWidth?: Props['labelStartWidth'];
+    labelWrapping?: Props['labelWrapping'];
+    max?: Props['max'];
+    messagesCustom?: Props['messagesCustom'];
+    min?: Props['min'];
+    monthAndYearPicker?: Props['monthAndYearPicker'];
+    readonly?: Props['readonly'];
+    required?: Props['required'];
+    requiredMessageDetail?: Props['requiredMessageDetail'];
+    textAlign?: Props['textAlign'];
+    todayButton?: Props['todayButton'];
+    todayTimeZone?: Props['todayTimeZone'];
+    userAssistanceDensity?: Props['userAssistanceDensity'];
+    validators?: Props['validators'];
+    value?: Props['value'];
+}
+export interface CInputDatePickerElementSettablePropertiesLenient extends Partial<CInputDatePickerElementSettableProperties> {
+    [key: string]: any;
+}
+export interface InputDatePickerIntrinsicProps extends Partial<Readonly<CInputDatePickerElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    oncolumnSpanChanged?: (value: CInputDatePickerElementEventMap['columnSpanChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CInputDatePickerElementEventMap['containerReadonlyChanged']) => void;
+    ondateRangeOverflowMessageDetailChanged?: (value: CInputDatePickerElementEventMap['dateRangeOverflowMessageDetailChanged']) => void;
+    ondateRangeUnderflowMessageDetailChanged?: (value: CInputDatePickerElementEventMap['dateRangeUnderflowMessageDetailChanged']) => void;
+    ondateRestrictionMessageDetailChanged?: (value: CInputDatePickerElementEventMap['dateRestrictionMessageDetailChanged']) => void;
+    ondayFormatterChanged?: (value: CInputDatePickerElementEventMap['dayFormatterChanged']) => void;
+    ondaysOutsideMonthChanged?: (value: CInputDatePickerElementEventMap['daysOutsideMonthChanged']) => void;
+    ondisabledChanged?: (value: CInputDatePickerElementEventMap['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CInputDatePickerElementEventMap['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CInputDatePickerElementEventMap['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CInputDatePickerElementEventMap['helpHintsChanged']) => void;
+    onlabelEdgeChanged?: (value: CInputDatePickerElementEventMap['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CInputDatePickerElementEventMap['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CInputDatePickerElementEventMap['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CInputDatePickerElementEventMap['labelWrappingChanged']) => void;
+    onmaxChanged?: (value: CInputDatePickerElementEventMap['maxChanged']) => void;
+    onmessagesCustomChanged?: (value: CInputDatePickerElementEventMap['messagesCustomChanged']) => void;
+    onminChanged?: (value: CInputDatePickerElementEventMap['minChanged']) => void;
+    onmonthAndYearPickerChanged?: (value: CInputDatePickerElementEventMap['monthAndYearPickerChanged']) => void;
+    onrawValueChanged?: (value: CInputDatePickerElementEventMap['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CInputDatePickerElementEventMap['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CInputDatePickerElementEventMap['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CInputDatePickerElementEventMap['requiredMessageDetailChanged']) => void;
+    ontextAlignChanged?: (value: CInputDatePickerElementEventMap['textAlignChanged']) => void;
+    ontodayButtonChanged?: (value: CInputDatePickerElementEventMap['todayButtonChanged']) => void;
+    ontodayTimeZoneChanged?: (value: CInputDatePickerElementEventMap['todayTimeZoneChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CInputDatePickerElementEventMap['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CInputDatePickerElementEventMap['validChanged']) => void;
+    onvalidatorsChanged?: (value: CInputDatePickerElementEventMap['validatorsChanged']) => void;
+    onvalueChanged?: (value: CInputDatePickerElementEventMap['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-input-date-picker': InputDatePickerIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/input-date-picker/useCombinedImplicitValidators.d.ts

@@ -0,0 +1,2 @@
+import type Validator = require('ojs/ojvalidator');
+export declare const useCombinedImplicitValidators: <V>(...validators: (Validator<V> | undefined)[]) => Validator<V>;

package/oj-c/types/input-date-picker/useImplicitCalendarDateConverter.d.ts

@@ -0,0 +1,7 @@
+import { BundleType } from '@oracle/oraclejet-preact/resources/nls/bundle';
+import { CalendarDateConverter } from 'oj-c/input-date-mask/CalendarDateConverter';
+type UseImplicitCalendarDateConverterProps = {
+    calendarDateConverter_parseErrorFn: BundleType['calendarDateConverter_parseError'];
+};
+export declare const useImplicitCalendarDateConverter: ({ calendarDateConverter_parseErrorFn }: UseImplicitCalendarDateConverterProps) => CalendarDateConverter;
+export {};

package/oj-c/types/input-date-picker/useImplicitDateRangeValidator.d.ts

@@ -0,0 +1,4 @@
+import { DateRangeValidator, DateRangeValidatorOptions } from './DateRangeValidator';
+type UseImplicitDateRangeValidatorProps = DateRangeValidatorOptions;
+export declare const useImplicitDateRangeValidator: ({ converter, defaultRangeOverflowMessageDetailFn, defaultRangeUnderflowMessageDetailFn, dateRangeOverflowMessageDetail, dateRangeUnderflowMessageDetail, formatObj, max, min }: UseImplicitDateRangeValidatorProps) => DateRangeValidator<string | null> | undefined;
+export {};

package/oj-c/types/input-date-picker/useImplicitDateRestrictionValidator.d.ts

@@ -0,0 +1,6 @@
+import { DateRestrictionValidator, DateRestrictionValidatorOptions } from './DateRestrictionValidator';
+type UseImplicitDateRestrictionValidatorProps = Pick<DateRestrictionValidatorOptions, 'converter' | 'dateRestrictionMessageDetail' | 'defaultRestrictionMessageDetail'> & {
+    dayFormatter?: DateRestrictionValidatorOptions['dayFormatter'];
+};
+export declare const useImplicitDateRestrictionValidator: ({ converter, dateRestrictionMessageDetail, dayFormatter, defaultRestrictionMessageDetail }: UseImplicitDateRestrictionValidatorProps) => DateRestrictionValidator<string | null> | undefined;
+export {};