@oracle/oraclejet-core-pack 16.1.3 → 17.0.0

package/oj-c/types/popup/popup.d.ts

@@ -0,0 +1,150 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ExtendGlobalProps, PropertyChanged, Action, CancelableAction, ObservedGlobalProps } from 'ojs/ojvcomponent';
+import { ComponentChildren, ComponentType } from 'preact';
+import 'css!oj-c/popup/popup-styles.css';
+import { InitialFocus, Tail, Modality, PopupPlacement } from '@oracle/oraclejet-preact/UNSAFE_Popup';
+import { Coords } from '@oracle/oraclejet-preact/UNSAFE_Floating';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+type PositionCollision = 'none' | 'flip' | 'fit' | 'flipfit' | 'flipcenter';
+type PopupOffset = {
+    x?: number;
+    y?: number;
+};
+export type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'aria-labelledby'> & {
+    children?: ComponentChildren;
+    opened: boolean;
+    launcher?: string | Element;
+    anchor?: string | Element | Coords;
+    placement?: PopupPlacement;
+    modality?: Modality;
+    autoDismiss?: 'none' | 'focusLoss';
+    tail?: Tail;
+    initialFocus?: InitialFocus;
+    offset?: PopupOffset;
+    collision?: PositionCollision;
+    onOpenedChanged?: PropertyChanged<boolean>;
+    onOjOpen?: Action;
+    onOjBeforeClose?: CancelableAction<object>;
+    onOjClose?: Action;
+    onOjFocus?: Action;
+    width?: Size;
+    minWidth?: Size;
+    maxWidth?: Size;
+    height?: Size;
+    minHeight?: Size;
+    maxHeight?: Size;
+};
+export declare const Popup: ComponentType<ExtendGlobalProps<Props>>;
+export {};
+export interface CPopupElement extends JetElement<CPopupElementSettableProperties>, CPopupElementSettableProperties {
+    addEventListener<T extends keyof CPopupElementEventMap>(type: T, listener: (this: HTMLElement, ev: CPopupElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CPopupElementSettableProperties>(property: T): CPopupElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CPopupElementSettableProperties>(property: T, value: CPopupElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CPopupElementSettableProperties>): void;
+    setProperties(properties: CPopupElementSettablePropertiesLenient): void;
+}
+export namespace CPopupElement {
+    interface ojOpen extends CustomEvent<{}> {
+    }
+    interface ojBeforeClose extends CustomEvent<{
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojClose extends CustomEvent<{}> {
+    }
+    interface ojFocus extends CustomEvent<{}> {
+    }
+    type anchorChanged = JetElementCustomEventStrict<CPopupElement['anchor']>;
+    type autoDismissChanged = JetElementCustomEventStrict<CPopupElement['autoDismiss']>;
+    type collisionChanged = JetElementCustomEventStrict<CPopupElement['collision']>;
+    type heightChanged = JetElementCustomEventStrict<CPopupElement['height']>;
+    type initialFocusChanged = JetElementCustomEventStrict<CPopupElement['initialFocus']>;
+    type launcherChanged = JetElementCustomEventStrict<CPopupElement['launcher']>;
+    type maxHeightChanged = JetElementCustomEventStrict<CPopupElement['maxHeight']>;
+    type maxWidthChanged = JetElementCustomEventStrict<CPopupElement['maxWidth']>;
+    type minHeightChanged = JetElementCustomEventStrict<CPopupElement['minHeight']>;
+    type minWidthChanged = JetElementCustomEventStrict<CPopupElement['minWidth']>;
+    type modalityChanged = JetElementCustomEventStrict<CPopupElement['modality']>;
+    type offsetChanged = JetElementCustomEventStrict<CPopupElement['offset']>;
+    type openedChanged = JetElementCustomEventStrict<CPopupElement['opened']>;
+    type placementChanged = JetElementCustomEventStrict<CPopupElement['placement']>;
+    type tailChanged = JetElementCustomEventStrict<CPopupElement['tail']>;
+    type widthChanged = JetElementCustomEventStrict<CPopupElement['width']>;
+}
+export interface CPopupElementEventMap extends HTMLElementEventMap {
+    'ojOpen': CPopupElement.ojOpen;
+    'ojBeforeClose': CPopupElement.ojBeforeClose;
+    'ojClose': CPopupElement.ojClose;
+    'ojFocus': CPopupElement.ojFocus;
+    'anchorChanged': JetElementCustomEventStrict<CPopupElement['anchor']>;
+    'autoDismissChanged': JetElementCustomEventStrict<CPopupElement['autoDismiss']>;
+    'collisionChanged': JetElementCustomEventStrict<CPopupElement['collision']>;
+    'heightChanged': JetElementCustomEventStrict<CPopupElement['height']>;
+    'initialFocusChanged': JetElementCustomEventStrict<CPopupElement['initialFocus']>;
+    'launcherChanged': JetElementCustomEventStrict<CPopupElement['launcher']>;
+    'maxHeightChanged': JetElementCustomEventStrict<CPopupElement['maxHeight']>;
+    'maxWidthChanged': JetElementCustomEventStrict<CPopupElement['maxWidth']>;
+    'minHeightChanged': JetElementCustomEventStrict<CPopupElement['minHeight']>;
+    'minWidthChanged': JetElementCustomEventStrict<CPopupElement['minWidth']>;
+    'modalityChanged': JetElementCustomEventStrict<CPopupElement['modality']>;
+    'offsetChanged': JetElementCustomEventStrict<CPopupElement['offset']>;
+    'openedChanged': JetElementCustomEventStrict<CPopupElement['opened']>;
+    'placementChanged': JetElementCustomEventStrict<CPopupElement['placement']>;
+    'tailChanged': JetElementCustomEventStrict<CPopupElement['tail']>;
+    'widthChanged': JetElementCustomEventStrict<CPopupElement['width']>;
+}
+export interface CPopupElementSettableProperties extends JetSettableProperties {
+    anchor?: Props['anchor'];
+    autoDismiss?: Props['autoDismiss'];
+    collision?: Props['collision'];
+    height?: Props['height'];
+    initialFocus?: Props['initialFocus'];
+    launcher?: Props['launcher'];
+    maxHeight?: Props['maxHeight'];
+    maxWidth?: Props['maxWidth'];
+    minHeight?: Props['minHeight'];
+    minWidth?: Props['minWidth'];
+    modality?: Props['modality'];
+    offset?: Props['offset'];
+    opened: Props['opened'];
+    placement?: Props['placement'];
+    tail?: Props['tail'];
+    width?: Props['width'];
+}
+export interface CPopupElementSettablePropertiesLenient extends Partial<CPopupElementSettableProperties> {
+    [key: string]: any;
+}
+export interface PopupIntrinsicProps extends Partial<Readonly<CPopupElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojBeforeClose?: (value: CPopupElementEventMap['ojBeforeClose']) => void;
+    onojClose?: (value: CPopupElementEventMap['ojClose']) => void;
+    onojFocus?: (value: CPopupElementEventMap['ojFocus']) => void;
+    onojOpen?: (value: CPopupElementEventMap['ojOpen']) => void;
+    onanchorChanged?: (value: CPopupElementEventMap['anchorChanged']) => void;
+    onautoDismissChanged?: (value: CPopupElementEventMap['autoDismissChanged']) => void;
+    oncollisionChanged?: (value: CPopupElementEventMap['collisionChanged']) => void;
+    onheightChanged?: (value: CPopupElementEventMap['heightChanged']) => void;
+    oninitialFocusChanged?: (value: CPopupElementEventMap['initialFocusChanged']) => void;
+    onlauncherChanged?: (value: CPopupElementEventMap['launcherChanged']) => void;
+    onmaxHeightChanged?: (value: CPopupElementEventMap['maxHeightChanged']) => void;
+    onmaxWidthChanged?: (value: CPopupElementEventMap['maxWidthChanged']) => void;
+    onminHeightChanged?: (value: CPopupElementEventMap['minHeightChanged']) => void;
+    onminWidthChanged?: (value: CPopupElementEventMap['minWidthChanged']) => void;
+    onmodalityChanged?: (value: CPopupElementEventMap['modalityChanged']) => void;
+    onoffsetChanged?: (value: CPopupElementEventMap['offsetChanged']) => void;
+    onopenedChanged?: (value: CPopupElementEventMap['openedChanged']) => void;
+    onplacementChanged?: (value: CPopupElementEventMap['placementChanged']) => void;
+    ontailChanged?: (value: CPopupElementEventMap['tailChanged']) => void;
+    onwidthChanged?: (value: CPopupElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-popup': PopupIntrinsicProps;
+        }
+    }
+}

package/oj-c/types/popup/resources/nls/popup-strings.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    root: {
+        popup: {
+            sampleString: string;
+        };
+    };
+};
+export = _default;

package/oj-c/types/radioset/useRadiosetPreact.d.ts

@@ -7,7 +7,7 @@ export declare function useRadiosetPreact({ direction, disabled, displayOptions,
         validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
     };
-    radiosetProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    radiosetProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
         children: import("preact").ComponentChildren;
@@ -25,7 +25,7 @@ export declare function useRadiosetPreact({ direction, disabled, displayOptions,
         onCommit: (detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string | number | undefined>) => void;
         userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
         value?: string | number | undefined;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
 };

package/oj-c/types/select-common/UNSAFE_useDataProviderListeners/useDataProviderListeners.d.ts

@@ -1,12 +1,12 @@
 import { ItemContext } from 'ojs/ojcommontypes';
 import { DataProvider } from 'ojs/ojdataprovider';
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 import { Optional } from '../utils/utils';
 export type UseDataProviderListenerProps<K extends string | number, D extends Record<string, any>, V extends K | Set<K>, VI extends ItemContext<K, D> | Map<K, ItemContext<K, D>>> = {
     dataProvider?: Optional<DataProvider<K, D>>;
-    setValue: StateUpdater<Optional<V>>;
-    setValueToSync: StateUpdater<Optional<V>>;
-    setValueItemsToSync: StateUpdater<Optional<VI>>;
+    setValue: Dispatch<StateUpdater<Optional<V>>>;
+    setValueToSync: Dispatch<StateUpdater<Optional<V>>>;
+    setValueItemsToSync: Dispatch<StateUpdater<Optional<VI>>>;
     value?: Optional<V>;
     valueItems?: Optional<VI>;
 };

package/oj-c/types/select-common/UNSAFE_useWrapValueState/useWrapValueState.d.ts

@@ -1,10 +1,10 @@
 import { ValueState } from 'oj-c/editable-value/UNSAFE_useValue/useValue';
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 type Props<ValueItemType> = {
     arItemContexts?: ValueItemType;
     isLoading?: boolean;
     preactValueItems?: ValueItemType;
-    setPreactValueItems: StateUpdater<ValueItemType | undefined>;
+    setPreactValueItems: Dispatch<StateUpdater<ValueItemType | undefined>>;
 };
 type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
 export declare function useWrapValueState<ValueType, ValueItemType>({ arItemContexts, isLoading, preactValueItems, setPreactValueItems }: Props<ValueItemType>): {
@@ -15,9 +15,9 @@ export declare function useWrapValueState<ValueType, ValueItemType>({ arItemCont
         transientValue: ValueType;
         value: ValueType;
         setValueAfterValidation: (value: ValueType) => void;
-        setDisplayValue: StateUpdater<string>;
-        setTransientValue: StateUpdater<ValueType>;
-        setValue: StateUpdater<ValueType>;
+        setDisplayValue: Dispatch<StateUpdater<string>>;
+        setTransientValue: Dispatch<StateUpdater<ValueType>>;
+        setValue: Dispatch<StateUpdater<ValueType>>;
     };
 };
 export {};

package/oj-c/types/select-common/utils/utils.d.ts

@@ -1,3 +1,4 @@
+import { DataProvider, TextFilter } from 'ojs/ojdataprovider';
 export type Optional<T> = T | null | undefined;
 export type MaybeMap<K, T> = Optional<T> | Map<K, T>;
 export type MaybeSet<T> = Optional<T> | Set<T>;
@@ -8,4 +9,5 @@ export declare const DEFAULT_VALUE_ITEM: null;
 export declare const DEFAULT_VALUE_ITEMS: null;
 export declare function isEmpty<K, T>(value: MaybeArray<K> | MaybeMap<K, T> | MaybeSet<K>): boolean;
 export declare function isSetEqual<K>(a: Set<K>, b: Set<K>): boolean;
+export declare function getFilterCriterion<K, D>(dataProvider?: DataProvider<K, D> | null, searchText?: string, paramMatchBy?: Array<TextFilter<D>['matchBy']> | null): import("ojs/ojdataprovider").AttributeFilter<any> | import("ojs/ojdataprovider").AttributeExprFilter<any> | import("ojs/ojdataprovider").ExtendedCompoundFilter<any> | import("ojs/ojdataprovider").NestedFilter<any> | TextFilter<any> | undefined;
 export {};

package/oj-c/types/select-multiple/select-multiple.d.ts

@@ -3,10 +3,10 @@ import { GlobalProps } from 'ojs/ojvcomponent';
 import 'ojs/oj-jsx-interfaces';
 import { SelectMultiple as PreactSelectMultiple } from '@oracle/oraclejet-preact/UNSAFE_SelectMultiple';
 import { ItemContext } from 'ojs/ojcommontypes';
-import { DataProvider, Item } from 'ojs/ojdataprovider';
+import { DataProvider, Item, TextFilter } from 'ojs/ojdataprovider';
 import { ImmutableKeySet } from 'ojs/ojkeyset';
 import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
-import { Component, ComponentProps } from 'preact';
+import { ComponentProps, ComponentType } from 'preact';
 import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
 import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
@@ -34,13 +34,13 @@ type Props<K extends string | number, D extends Record<string, any>> = ObservedG
     labelHint: string;
     labelStartWidth?: Size;
     labelWrapping?: 'truncate' | 'wrap';
+    matchBy?: Array<TextFilter<D>['matchBy']> | null;
     messagesCustom?: PreactSelectMultipleProps['messages'];
     placeholder?: string;
     readonly?: boolean;
     required?: boolean;
     requiredMessageDetail?: string;
     textAlign?: PreactSelectMultipleProps['textAlign'];
-    unsafe_labelledBy?: string;
     userAssistanceDensity?: PreactSelectMultipleProps['userAssistanceDensity'];
     value?: Set<K> | null;
     valueItems?: Map<K, ItemContext<K, D>> | null;
@@ -50,21 +50,7 @@ type Props<K extends string | number, D extends Record<string, any>> = ObservedG
     onValueChanged?: PropertyChanged<Set<K> | null | undefined>;
     onValueItemsChanged?: PropertyChanged<Map<K, ItemContext<K, D>> | null | undefined>;
 };
-export declare class SelectMultiple<K extends string | number, D extends Record<string, any>> extends Component<ExtendGlobalProps<Props<K, D>>> {
-    static defaultProps: Pick<Props<any, any>, 'columnSpan' | 'data' | 'disabled' | 'displayOptions' | 'help' | 'helpHints' | 'messagesCustom' | 'readonly' | 'required' | 'requiredMessageDetail' | 'userAssistanceDensity' | 'value' | 'valueItems' | 'virtualKeyboard'>;
-    private busyContextRef;
-    private selectMultipleRef;
-    private rootRef;
-    componentDidMount(): void;
-    render({ columnSpan, ...props }: ExtendGlobalProps<Props<K, D>>): import("preact").JSX.Element;
-    componentWillUnmount(): void;
-    reset(): void;
-    showMessages(): void;
-    validate(): Promise<'valid' | 'invalid'>;
-    blur(): void;
-    focus(): void;
-    _selectItemsByValue(value: Set<K> | null): Promise<void> | undefined;
-}
+export declare const SelectMultiple: ComponentType<ExtendGlobalProps<Props<string | number, Record<string, any>>>>;
 export type SelectMultipleProps<K extends string | number, D extends Record<string, any>> = Props<K, D>;
 export {};
 export interface CSelectMultipleElement<K extends string | number, D extends Record<string, any>> extends JetElement<CSelectMultipleElementSettableProperties<K, D>>, CSelectMultipleElementSettableProperties<K, D> {
@@ -76,12 +62,12 @@ export interface CSelectMultipleElement<K extends string | number, D extends Rec
     setProperty<T extends keyof CSelectMultipleElementSettableProperties<K, D>>(property: T, value: CSelectMultipleElementSettableProperties<K, D>[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CSelectMultipleElementSettableProperties<K, D>>): void;
     setProperties(properties: CSelectMultipleElementSettablePropertiesLenient<K, D>): void;
-    _selectItemsByValue: SelectMultiple<K, D>['_selectItemsByValue'];
-    blur: SelectMultiple<K, D>['blur'];
-    focus: SelectMultiple<K, D>['focus'];
-    reset: SelectMultiple<K, D>['reset'];
-    showMessages: SelectMultiple<K, D>['showMessages'];
-    validate: SelectMultiple<K, D>['validate'];
+    _selectItemsByValue: (value: Set<K> | null) => Promise<void>;
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
 }
 export namespace CSelectMultipleElement {
     type columnSpanChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['columnSpan']>;
@@ -96,18 +82,19 @@ export namespace CSelectMultipleElement {
     type labelHintChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelHint']>;
     type labelStartWidthChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelStartWidth']>;
     type labelWrappingChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelWrapping']>;
+    type matchByChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['matchBy']>;
     type messagesCustomChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['messagesCustom']>;
     type placeholderChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['placeholder']>;
     type readonlyChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['readonly']>;
     type requiredChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['required']>;
     type requiredMessageDetailChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['requiredMessageDetail']>;
     type textAlignChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['textAlign']>;
-    type unsafe_labelledByChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['unsafe_labelledBy']>;
     type userAssistanceDensityChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['userAssistanceDensity']>;
     type validChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['valid']>;
     type valueChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['value']>;
     type valueItemsChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['valueItems']>;
     type virtualKeyboardChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['virtualKeyboard']>;
+    type RenderItemTemplate<K extends string | number, D extends Record<string, any>> = import('ojs/ojvcomponent').TemplateSlot<ItemTemplateContext<K, D>>;
 }
 export interface CSelectMultipleElementEventMap<K extends string | number, D extends Record<string, any>> extends HTMLElementEventMap {
     'columnSpanChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['columnSpan']>;
@@ -122,13 +109,13 @@ export interface CSelectMultipleElementEventMap<K extends string | number, D ext
     'labelHintChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelHint']>;
     'labelStartWidthChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelStartWidth']>;
     'labelWrappingChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelWrapping']>;
+    'matchByChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['matchBy']>;
     'messagesCustomChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['messagesCustom']>;
     'placeholderChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['placeholder']>;
     'readonlyChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['readonly']>;
     'requiredChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['required']>;
     'requiredMessageDetailChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['requiredMessageDetail']>;
     'textAlignChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['textAlign']>;
-    'unsafe_labelledByChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['unsafe_labelledBy']>;
     'userAssistanceDensityChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['userAssistanceDensity']>;
     'validChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['valid']>;
     'valueChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['value']>;
@@ -148,13 +135,13 @@ export interface CSelectMultipleElementSettableProperties<K extends string | num
     labelHint: Props<K, D>['labelHint'];
     labelStartWidth?: Props<K, D>['labelStartWidth'];
     labelWrapping?: Props<K, D>['labelWrapping'];
+    matchBy?: Props<K, D>['matchBy'];
     messagesCustom?: Props<K, D>['messagesCustom'];
     placeholder?: Props<K, D>['placeholder'];
     readonly?: Props<K, D>['readonly'];
     required?: Props<K, D>['required'];
     requiredMessageDetail?: Props<K, D>['requiredMessageDetail'];
     textAlign?: Props<K, D>['textAlign'];
-    unsafe_labelledBy?: Props<K, D>['unsafe_labelledBy'];
     userAssistanceDensity?: Props<K, D>['userAssistanceDensity'];
     value?: Props<K, D>['value'];
     valueItems?: Props<K, D>['valueItems'];
@@ -178,13 +165,13 @@ export interface SelectMultipleIntrinsicProps extends Partial<Readonly<CSelectMu
     onlabelHintChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelHintChanged']) => void;
     onlabelStartWidthChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelStartWidthChanged']) => void;
     onlabelWrappingChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelWrappingChanged']) => void;
+    onmatchByChanged?: (value: CSelectMultipleElementEventMap<any, any>['matchByChanged']) => void;
     onmessagesCustomChanged?: (value: CSelectMultipleElementEventMap<any, any>['messagesCustomChanged']) => void;
     onplaceholderChanged?: (value: CSelectMultipleElementEventMap<any, any>['placeholderChanged']) => void;
     onreadonlyChanged?: (value: CSelectMultipleElementEventMap<any, any>['readonlyChanged']) => void;
     onrequiredChanged?: (value: CSelectMultipleElementEventMap<any, any>['requiredChanged']) => void;
     onrequiredMessageDetailChanged?: (value: CSelectMultipleElementEventMap<any, any>['requiredMessageDetailChanged']) => void;
     ontextAlignChanged?: (value: CSelectMultipleElementEventMap<any, any>['textAlignChanged']) => void;
-    onunsafe_labelledByChanged?: (value: CSelectMultipleElementEventMap<any, any>['unsafe_labelledByChanged']) => void;
     onuserAssistanceDensityChanged?: (value: CSelectMultipleElementEventMap<any, any>['userAssistanceDensityChanged']) => void;
     onvalidChanged?: (value: CSelectMultipleElementEventMap<any, any>['validChanged']) => void;
     onvalueChanged?: (value: CSelectMultipleElementEventMap<any, any>['valueChanged']) => void;

package/oj-c/types/select-multiple/useSelectMultiplePreact.d.ts

@@ -1,14 +1,12 @@
 import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
-import { ComponentProps } from 'preact';
-import type { SelectMultiple } from './select-multiple';
-type SelectMultipleProps = ComponentProps<typeof SelectMultiple>;
-export declare function useSelectMultiplePreact<K extends string | number, D extends Record<string, any>>({ data: propData, disabled, displayOptions, itemTemplate, itemText, labelEdge, labelHint, labelStartWidth, messagesCustom, placeholder, readonly, required, requiredMessageDetail: propRequiredMessageDetail, textAlign, userAssistanceDensity, value: propValue, valueItems: propValueItems, virtualKeyboard, onMessagesCustomChanged, onValidChanged, onValueChanged, onValueItemsChanged, ...otherProps }: SelectMultipleProps, addBusyState: (desc?: string) => () => void): {
+import type { SelectMultipleProps } from './select-multiple';
+export declare function useSelectMultiplePreact<K extends string | number, D extends Record<string, any>>({ data: propData, disabled, displayOptions, itemTemplate, itemText, labelEdge, labelHint, labelStartWidth, matchBy: propMatchBy, messagesCustom, placeholder, readonly, required, requiredMessageDetail: propRequiredMessageDetail, textAlign, userAssistanceDensity, value: propValue, valueItems: propValueItems, virtualKeyboard, onMessagesCustomChanged, onValidChanged, onValueChanged, onValueItemsChanged, ...otherProps }: SelectMultipleProps<K, D>, addBusyState: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
     };
-    selectMultipleProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    selectMultipleProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         addToList?: "off" | "on" | undefined;
         'aria-describedby'?: string | undefined;
         assistiveText?: string | undefined;
@@ -41,9 +39,8 @@ export declare function useSelectMultiplePreact<K extends string | number, D ext
             searchText?: string | undefined;
         }) => void) | undefined;
         onLoadRange?: ((range: import("@oracle/oraclejet-preact/UNSAFE_Collection").Range) => void) | undefined;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
     _selectItemsByValue: (value: Set<K> | null) => Promise<void>;
 };
-export {};

package/oj-c/types/select-multiple/useSyncValueAndValueItems.d.ts

@@ -1,17 +1,20 @@
+import { ValidationResult } from 'oj-c/editable-value/UNSAFE_useValidators/useValidators';
 import { ItemContext } from 'ojs/ojcommontypes';
 import { DataProvider } from 'ojs/ojdataprovider';
-import { StateUpdater } from 'preact/hooks';
+import { Dispatch, StateUpdater } from 'preact/hooks';
 type Optional<T> = T | null | undefined;
 type Value<K> = Optional<Set<K>>;
 type ValueItems<K, D> = Optional<Map<K, ItemContext<K, D>>>;
 export type UseSyncValueAndValueItemsProps<K, D> = {
     addBusyState: (desc?: string) => () => void;
     dataProvider?: Optional<DataProvider<K, D>>;
-    setIsLoading: StateUpdater<boolean>;
-    setValue: StateUpdater<Value<K>>;
+    setDisplayValue: Dispatch<StateUpdater<Value<K>>>;
+    setIsLoading: Dispatch<StateUpdater<boolean>>;
+    setValue: Dispatch<StateUpdater<Value<K>>>;
     setValueItems: (value: ValueItems<K, D>) => void;
     value?: Value<K>;
     valueItems?: ValueItems<K, D>;
+    validateValueOnExternalChange: (value: Value<K>) => ValidationResult;
 };
-export declare function useSyncValueAndValueItems<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setIsLoading, setValue, setValueItems, value, valueItems }: UseSyncValueAndValueItemsProps<K, D>): void;
+export declare function useSyncValueAndValueItems<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setDisplayValue, setIsLoading, setValue, setValueItems, value, valueItems, validateValueOnExternalChange }: UseSyncValueAndValueItemsProps<K, D>): void;
 export {};

package/oj-c/types/select-single/select-single.d.ts

@@ -4,9 +4,9 @@ import 'ojs/oj-jsx-interfaces';
 import { SelectSingle as PreactSelectSingle } from '@oracle/oraclejet-preact/UNSAFE_SelectSingle';
 import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
 import { ItemContext } from 'ojs/ojcommontypes';
-import { DataProvider, Item } from 'ojs/ojdataprovider';
+import { DataProvider, Item, TextFilter } from 'ojs/ojdataprovider';
 import { Action, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
-import { Component, ComponentProps } from 'preact';
+import { ComponentProps, ComponentType } from 'preact';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
 import { LayoutColumnSpan } from '@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout';
 import 'css!oj-c/select-single/select-single-styles.css';
@@ -36,13 +36,13 @@ type Props<V extends string | number, D extends Record<string, any>> = ObservedG
     labelHint: string;
     labelStartWidth?: Size;
     labelWrapping?: 'truncate' | 'wrap';
+    matchBy?: Array<TextFilter<D>['matchBy']> | null;
     messagesCustom?: PreactSelectSingleProps['messages'];
     placeholder?: string;
     readonly?: boolean;
     required?: boolean;
     requiredMessageDetail?: string;
     textAlign?: PreactSelectSingleProps['textAlign'];
-    unsafe_labelledBy?: string;
     userAssistanceDensity?: PreactSelectSingleProps['userAssistanceDensity'];
     value?: V | null;
     valueItem?: ItemContext<V, D> | null;
@@ -54,22 +54,7 @@ type Props<V extends string | number, D extends Record<string, any>> = ObservedG
     onOjAdvancedSearchAction?: Action<AdvancedSearchActionPayload>;
     onOjValueAction?: Action<ValueActionPayload<V, D>>;
 };
-export declare class SelectSingle<V extends string | number, D extends Record<string, any>> extends Component<ExtendGlobalProps<Props<V, D>>> {
-    static defaultProps: Pick<Props<any, any>, 'advancedSearch' | 'columnSpan' | 'data' | 'disabled' | 'displayOptions' | 'help' | 'helpHints' | 'messagesCustom' | 'readonly' | 'required' | 'requiredMessageDetail' | 'userAssistanceDensity' | 'value' | 'valueItem' | 'virtualKeyboard'>;
-    private busyContextRef;
-    private selectSingleRef;
-    private rootRef;
-    componentDidMount(): void;
-    render({ columnSpan, ...props }: ExtendGlobalProps<Props<V, D>>): import("preact").JSX.Element;
-    componentWillUnmount(): void;
-    reset(): void;
-    showMessages(): void;
-    validate(): Promise<'valid' | 'invalid'>;
-    blur(): void;
-    focus(): void;
-    _doAdvancedSearchAction(searchText: string): void | undefined;
-    _selectItemByValue(value: V | null): Promise<void> | undefined;
-}
+export declare const SelectSingle: ComponentType<ExtendGlobalProps<Props<string | number, Record<string, any>>>>;
 export type SelectSingleProps<V extends string | number, D extends Record<string, any>> = Props<V, D>;
 export {};
 export interface CSelectSingleElement<V extends string | number, D extends Record<string, any>> extends JetElement<CSelectSingleElementSettableProperties<V, D>>, CSelectSingleElementSettableProperties<V, D> {
@@ -81,13 +66,13 @@ export interface CSelectSingleElement<V extends string | number, D extends Recor
     setProperty<T extends keyof CSelectSingleElementSettableProperties<V, D>>(property: T, value: CSelectSingleElementSettableProperties<V, D>[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CSelectSingleElementSettableProperties<V, D>>): void;
     setProperties(properties: CSelectSingleElementSettablePropertiesLenient<V, D>): void;
-    _doAdvancedSearchAction: SelectSingle<V, D>['_doAdvancedSearchAction'];
-    _selectItemByValue: SelectSingle<V, D>['_selectItemByValue'];
-    blur: SelectSingle<V, D>['blur'];
-    focus: SelectSingle<V, D>['focus'];
-    reset: SelectSingle<V, D>['reset'];
-    showMessages: SelectSingle<V, D>['showMessages'];
-    validate: SelectSingle<V, D>['validate'];
+    _doAdvancedSearchAction: (searchText: string) => void;
+    _selectItemByValue: (value: V | null) => Promise<void>;
+    blur: () => void;
+    focus: () => void;
+    reset: () => void;
+    showMessages: () => void;
+    validate: () => Promise<'invalid' | 'valid'>;
 }
 export namespace CSelectSingleElement {
     interface ojAdvancedSearchAction extends CustomEvent<{
@@ -109,18 +94,19 @@ export namespace CSelectSingleElement {
     type labelHintChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelHint']>;
     type labelStartWidthChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelStartWidth']>;
     type labelWrappingChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelWrapping']>;
+    type matchByChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['matchBy']>;
     type messagesCustomChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['messagesCustom']>;
     type placeholderChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['placeholder']>;
     type readonlyChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['readonly']>;
     type requiredChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['required']>;
     type requiredMessageDetailChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['requiredMessageDetail']>;
     type textAlignChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['textAlign']>;
-    type unsafe_labelledByChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['unsafe_labelledBy']>;
     type userAssistanceDensityChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['userAssistanceDensity']>;
     type validChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['valid']>;
     type valueChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['value']>;
     type valueItemChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['valueItem']>;
     type virtualKeyboardChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['virtualKeyboard']>;
+    type RenderItemTemplate<V extends string | number, D extends Record<string, any>> = import('ojs/ojvcomponent').TemplateSlot<ItemTemplateContext<V, D>>;
 }
 export interface CSelectSingleElementEventMap<V extends string | number, D extends Record<string, any>> extends HTMLElementEventMap {
     'ojAdvancedSearchAction': CSelectSingleElement.ojAdvancedSearchAction;
@@ -138,13 +124,13 @@ export interface CSelectSingleElementEventMap<V extends string | number, D exten
     'labelHintChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelHint']>;
     'labelStartWidthChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelStartWidth']>;
     'labelWrappingChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelWrapping']>;
+    'matchByChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['matchBy']>;
     'messagesCustomChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['messagesCustom']>;
     'placeholderChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['placeholder']>;
     'readonlyChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['readonly']>;
     'requiredChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['required']>;
     'requiredMessageDetailChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['requiredMessageDetail']>;
     'textAlignChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['textAlign']>;
-    'unsafe_labelledByChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['unsafe_labelledBy']>;
     'userAssistanceDensityChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['userAssistanceDensity']>;
     'validChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['valid']>;
     'valueChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['value']>;
@@ -165,13 +151,13 @@ export interface CSelectSingleElementSettableProperties<V extends string | numbe
     labelHint: Props<V, D>['labelHint'];
     labelStartWidth?: Props<V, D>['labelStartWidth'];
     labelWrapping?: Props<V, D>['labelWrapping'];
+    matchBy?: Props<V, D>['matchBy'];
     messagesCustom?: Props<V, D>['messagesCustom'];
     placeholder?: Props<V, D>['placeholder'];
     readonly?: Props<V, D>['readonly'];
     required?: Props<V, D>['required'];
     requiredMessageDetail?: Props<V, D>['requiredMessageDetail'];
     textAlign?: Props<V, D>['textAlign'];
-    unsafe_labelledBy?: Props<V, D>['unsafe_labelledBy'];
     userAssistanceDensity?: Props<V, D>['userAssistanceDensity'];
     value?: Props<V, D>['value'];
     valueItem?: Props<V, D>['valueItem'];
@@ -198,13 +184,13 @@ export interface SelectSingleIntrinsicProps extends Partial<Readonly<CSelectSing
     onlabelHintChanged?: (value: CSelectSingleElementEventMap<any, any>['labelHintChanged']) => void;
     onlabelStartWidthChanged?: (value: CSelectSingleElementEventMap<any, any>['labelStartWidthChanged']) => void;
     onlabelWrappingChanged?: (value: CSelectSingleElementEventMap<any, any>['labelWrappingChanged']) => void;
+    onmatchByChanged?: (value: CSelectSingleElementEventMap<any, any>['matchByChanged']) => void;
     onmessagesCustomChanged?: (value: CSelectSingleElementEventMap<any, any>['messagesCustomChanged']) => void;
     onplaceholderChanged?: (value: CSelectSingleElementEventMap<any, any>['placeholderChanged']) => void;
     onreadonlyChanged?: (value: CSelectSingleElementEventMap<any, any>['readonlyChanged']) => void;
     onrequiredChanged?: (value: CSelectSingleElementEventMap<any, any>['requiredChanged']) => void;
     onrequiredMessageDetailChanged?: (value: CSelectSingleElementEventMap<any, any>['requiredMessageDetailChanged']) => void;
     ontextAlignChanged?: (value: CSelectSingleElementEventMap<any, any>['textAlignChanged']) => void;
-    onunsafe_labelledByChanged?: (value: CSelectSingleElementEventMap<any, any>['unsafe_labelledByChanged']) => void;
     onuserAssistanceDensityChanged?: (value: CSelectSingleElementEventMap<any, any>['userAssistanceDensityChanged']) => void;
     onvalidChanged?: (value: CSelectSingleElementEventMap<any, any>['validChanged']) => void;
     onvalueChanged?: (value: CSelectSingleElementEventMap<any, any>['valueChanged']) => void;

package/oj-c/types/select-single/useSelectSinglePreact.d.ts

@@ -1,15 +1,12 @@
 import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
-import { ComponentProps } from 'preact';
-import type { SelectSingle } from './select-single';
-type SelectSingleProps = ComponentProps<typeof SelectSingle>;
-type V = string | number;
-export declare function useSelectSinglePreact({ advancedSearch, data: propData, disabled, displayOptions, itemTemplate, itemText, labelEdge, labelHint, labelStartWidth, messagesCustom, placeholder, readonly, requiredMessageDetail: propRequiredMessageDetail, required, textAlign, userAssistanceDensity, value: propValue, valueItem: propValueItem, virtualKeyboard, onMessagesCustomChanged, onOjAdvancedSearchAction, onOjValueAction, onValidChanged, onValueChanged, onValueItemChanged, ...otherProps }: SelectSingleProps, addBusyState: (desc?: string) => () => void): {
+import type { SelectSingleProps } from './select-single';
+export declare function useSelectSinglePreact<V extends string | number, D extends Record<string, any>>({ advancedSearch, data: propData, disabled, displayOptions, itemTemplate, itemText, labelEdge, labelHint, labelStartWidth, matchBy: propMatchBy, messagesCustom, placeholder, readonly, requiredMessageDetail: propRequiredMessageDetail, required, textAlign, userAssistanceDensity, value: propValue, valueItem: propValueItem, virtualKeyboard, onMessagesCustomChanged, onOjAdvancedSearchAction, onOjValueAction, onValidChanged, onValueChanged, onValueItemChanged, ...otherProps }: SelectSingleProps<V, D>, addBusyState: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         validate: () => Promise<"invalid" | "valid">;
         showMessages: () => void;
     };
-    selectSingleProps: Omit<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
+    selectSingleProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
         addToList?: "off" | "on" | undefined;
         advancedSearch?: "off" | "on" | undefined;
         'aria-describedby'?: string | undefined;
@@ -60,10 +57,9 @@ export declare function useSelectSinglePreact({ advancedSearch, data: propData,
             searchText?: string | undefined;
         }) => void) | undefined;
         onLoadRange?: ((range: import("@oracle/oraclejet-preact/UNSAFE_Collection").Range) => void) | undefined;
-    }, "ref"> & {
+    }> & {
         ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
     };
     _doAdvancedSearchAction: (searchText: string) => void;
     _selectItemByValue: (value: V | null) => Promise<void>;
 };
-export {};