@oracle/oraclejet-core-pack 14.0.0

package/oj-c/types/select-common/UNSAFE_useWrapDataProvider/useWrapDataProvider.d.ts

@@ -0,0 +1,3 @@
+import { DataProvider } from 'ojs/ojdataprovider';
+import { Optional } from '../utils/utils';
+export declare function useWrapDataProvider<K, D>(data?: Optional<DataProvider<K, D>>): DataProvider<K, D> | null | undefined;

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

@@ -0,0 +1 @@
+export { useWrapValueState } from './useWrapValueState';

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

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

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

@@ -0,0 +1,10 @@
+export declare type Optional<T> = T | null | undefined;
+export declare type MaybeMap<K, T> = Optional<T> | Map<K, T>;
+export declare type MaybeSet<T> = Optional<T> | Set<T>;
+declare type MaybeArray<T> = Optional<T | T[]>;
+export declare const DEFAULT_ITEM_CONTEXT: null;
+export declare const DEFAULT_VALUE: null;
+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 {};

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

@@ -0,0 +1,2 @@
+export { SelectMultiple } from './select-multiple';
+export { CSelectMultipleElement } from './select-multiple';

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

@@ -0,0 +1,176 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { SelectMultiple as PreactSelectMultiple } from '@oracle/oraclejet-preact/UNSAFE_SelectMultiple';
+import * as CommonTypes from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import { DisplayOptions, Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import 'css!oj-c/select-multiple/select-multiple-styles.css';
+declare type PreactSelectMultipleProps = ComponentProps<typeof PreactSelectMultiple>;
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type Props<K extends string | number, D extends Record<string, any>> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    containerReadonly?: boolean;
+    data?: DataProvider<K, D> | null;
+    disabled?: boolean;
+    displayOptions?: Omit<DisplayOptions, 'converterHint' | 'validatorHint'>;
+    help?: Help;
+    helpHints?: HelpHints;
+    itemText: keyof D | ((itemContext: CommonTypes.ItemContext<K, D>) => string);
+    labelEdge?: PreactSelectMultipleProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    messagesCustom?: PreactSelectMultipleProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    textAlign?: PreactSelectMultipleProps['textAlign'];
+    userAssistanceDensity?: PreactSelectMultipleProps['userAssistanceDensity'];
+    value?: Set<K> | null;
+    valueItems?: Map<K, CommonTypes.ItemContext<K, D>> | null;
+    virtualKeyboard?: PreactSelectMultipleProps['virtualKeyboard'];
+    onMessagesCustomChanged?: PropertyChanged<PreactSelectMultipleProps['messages']>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<Set<K> | null | undefined>;
+    onValueItemsChanged?: PropertyChanged<Map<K, CommonTypes.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>, 'data' | 'disabled' | 'displayOptions' | 'help' | 'helpHints' | 'messagesCustom' | 'readonly' | 'required' | 'requiredMessageDetail' | 'userAssistanceDensity' | 'value' | 'valueItems' | 'virtualKeyboard'>;
+    private busyContextRef;
+    private selectMultipleRef;
+    private rootRef;
+    componentDidMount(): void;
+    render(props: ExtendGlobalProps<Props<K, D>>): import("preact").JSX.Element;
+    componentWillUnmount(): void;
+    reset(): void;
+    showMessages(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+    blur(): void;
+    focus(): void;
+}
+export declare 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> {
+    readonly valid?: Parameters<Required<Props<K, D>>['onValidChanged']>[0];
+    addEventListener<T extends keyof CSelectMultipleElementEventMap<K, D>>(type: T, listener: (this: HTMLElement, ev: CSelectMultipleElementEventMap<K, D>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CSelectMultipleElementSettableProperties<K, D>>(property: T): CSelectMultipleElement<K, D>[T];
+    getProperty(property: string): any;
+    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;
+    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'];
+}
+export namespace CSelectMultipleElement {
+    type containerReadonlyChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['containerReadonly']>;
+    type dataChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['data']>;
+    type disabledChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['disabled']>;
+    type displayOptionsChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['displayOptions']>;
+    type helpChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['help']>;
+    type helpHintsChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['helpHints']>;
+    type itemTextChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['itemText']>;
+    type labelEdgeChanged<K extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelEdge']>;
+    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 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 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']>;
+}
+export interface CSelectMultipleElementEventMap<K extends string | number, D extends Record<string, any>> extends HTMLElementEventMap {
+    'containerReadonlyChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['containerReadonly']>;
+    'dataChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['data']>;
+    'disabledChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['helpHints']>;
+    'itemTextChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['itemText']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['labelWrapping']>;
+    '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']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['valid']>;
+    'valueChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['value']>;
+    'valueItemsChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['valueItems']>;
+    'virtualKeyboardChanged': JetElementCustomEventStrict<CSelectMultipleElement<K, D>['virtualKeyboard']>;
+}
+export interface CSelectMultipleElementSettableProperties<K extends string | number, D extends Record<string, any>> extends JetSettableProperties {
+    containerReadonly?: Props<K, D>['containerReadonly'];
+    data?: Props<K, D>['data'];
+    disabled?: Props<K, D>['disabled'];
+    displayOptions?: Props<K, D>['displayOptions'];
+    help?: Props<K, D>['help'];
+    helpHints?: Props<K, D>['helpHints'];
+    itemText: Props<K, D>['itemText'];
+    labelEdge?: Props<K, D>['labelEdge'];
+    labelHint: Props<K, D>['labelHint'];
+    labelStartWidth?: Props<K, D>['labelStartWidth'];
+    labelWrapping?: Props<K, D>['labelWrapping'];
+    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'];
+    userAssistanceDensity?: Props<K, D>['userAssistanceDensity'];
+    value?: Props<K, D>['value'];
+    valueItems?: Props<K, D>['valueItems'];
+    virtualKeyboard?: Props<K, D>['virtualKeyboard'];
+}
+export interface CSelectMultipleElementSettablePropertiesLenient<K extends string | number, D extends Record<string, any>> extends Partial<CSelectMultipleElementSettableProperties<K, D>> {
+    [key: string]: any;
+}
+export interface SelectMultipleIntrinsicProps extends Partial<Readonly<CSelectMultipleElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    valid?: never;
+    oncontainerReadonlyChanged?: (value: CSelectMultipleElementEventMap<any, any>['containerReadonlyChanged']) => void;
+    ondataChanged?: (value: CSelectMultipleElementEventMap<any, any>['dataChanged']) => void;
+    ondisabledChanged?: (value: CSelectMultipleElementEventMap<any, any>['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CSelectMultipleElementEventMap<any, any>['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CSelectMultipleElementEventMap<any, any>['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CSelectMultipleElementEventMap<any, any>['helpHintsChanged']) => void;
+    onitemTextChanged?: (value: CSelectMultipleElementEventMap<any, any>['itemTextChanged']) => void;
+    onlabelEdgeChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CSelectMultipleElementEventMap<any, any>['labelWrappingChanged']) => 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;
+    onuserAssistanceDensityChanged?: (value: CSelectMultipleElementEventMap<any, any>['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CSelectMultipleElementEventMap<any, any>['validChanged']) => void;
+    onvalueChanged?: (value: CSelectMultipleElementEventMap<any, any>['valueChanged']) => void;
+    onvalueItemsChanged?: (value: CSelectMultipleElementEventMap<any, any>['valueItemsChanged']) => void;
+    onvirtualKeyboardChanged?: (value: CSelectMultipleElementEventMap<any, any>['virtualKeyboardChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-select-multiple': SelectMultipleIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import { ComponentProps } from 'preact';
+import type { SelectMultiple } from './select-multiple';
+declare type SelectMultipleProps = ComponentProps<typeof SelectMultiple>;
+export declare function useSelectMultiplePreact<K extends string | number, D extends Record<string, any>>({ data: propData, disabled, displayOptions, itemText, labelEdge, labelHint, labelStartWidth, messagesCustom, placeholder, readonly, required, textAlign, userAssistanceDensity, value: propValue, valueItems: propValueItems, virtualKeyboard, onMessagesCustomChanged, onValidChanged, onValueChanged, onValueItemsChanged, ...otherProps }: SelectMultipleProps, addBusyState: (desc?: string) => () => void): {
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    selectMultipleProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        data?: import("@oracle/oraclejet-preact/UNSAFE_Collection").DataState<string | number, Record<string, any>> | null | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isLoading?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        itemText: import("@oracle/oraclejet-preact/utils/UNSAFE_selectUtils").ItemTextType<string | number, Record<string, any>>;
+        label: string;
+        labelEdge?: "start" | "none" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        placeholder?: string | undefined;
+        textAlign?: "start" | "right" | "end" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        valueItems?: import("@oracle/oraclejet-preact/utils/UNSAFE_dataProvider").Item<string | number, Record<string, any>>[] | undefined;
+        variant?: "default" | "embedded" | undefined;
+        virtualKeyboard?: "number" | "text" | "auto" | "search" | "email" | "tel" | "url" | undefined;
+        onCommit: (detail: ValueUpdateDetail<Set<string | number>>) => void;
+        onFilter?: (({ searchText }: {
+            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;
+    };
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+import { StateUpdater } from 'preact/hooks';
+declare type Optional<T> = T | null | undefined;
+declare type Value<K> = Optional<Set<K>>;
+declare type ValueItems<K, D> = Optional<Map<K, ItemContext<K, D>>>;
+export declare type UseSyncValueAndValueItemsProps<K, D> = {
+    addBusyState: (desc?: string) => () => void;
+    dataProvider?: Optional<DataProvider<K, D>>;
+    setIsLoading: StateUpdater<boolean>;
+    setValue: StateUpdater<Value<K>>;
+    setValueItems: (value: ValueItems<K, D>) => void;
+    value?: Value<K>;
+    valueItems?: ValueItems<K, D>;
+};
+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 {};

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

@@ -0,0 +1,6 @@
+import { PropertyChanged } from 'ojs/ojvcomponent';
+export declare function useValueItems<K, D>(propValueItems?: Map<K, D> | null, onValueItemsChanged?: PropertyChanged<Map<K, D> | null | undefined>): {
+    valueItems: Map<K, D> | null | undefined;
+    setValueItems: (value: Map<K, D> | null, ...args: any[]) => void;
+    preactValueItems: D[] | undefined;
+};

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

@@ -0,0 +1,2 @@
+export { SelectSingle } from './select-single';
+export { CSelectSingleElement } from './select-single';

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

@@ -0,0 +1,186 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+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 } from 'ojs/ojdataprovider';
+import { Action, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import 'css!./select-single-styles.css';
+declare type PreactSelectSingleProps = ComponentProps<typeof PreactSelectSingle>;
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type ValueActionPayload<V, D> = {
+    itemContext: ItemContext<V, D> | null;
+    previousValue: V | null;
+    value: V | null;
+};
+declare type Props<V extends string | number, D extends Record<string, any>> = ObservedGlobalProps<'aria-describedby' | 'id'> & {
+    containerReadonly?: boolean;
+    data?: DataProvider<V, D> | null;
+    disabled?: boolean;
+    displayOptions?: Omit<DisplayOptions, 'converterHint' | 'validatorHint'>;
+    help?: Help;
+    helpHints?: HelpHints;
+    itemText: keyof D | ((itemContext: ItemContext<V, D>) => string);
+    labelEdge?: PreactSelectSingleProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    messagesCustom?: PreactSelectSingleProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    textAlign?: PreactSelectSingleProps['textAlign'];
+    userAssistanceDensity?: PreactSelectSingleProps['userAssistanceDensity'];
+    value?: V | null;
+    valueItem?: ItemContext<V, D> | null;
+    virtualKeyboard?: PreactSelectSingleProps['virtualKeyboard'];
+    onMessagesCustomChanged?: PropertyChanged<PreactSelectSingleProps['messages']>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<V | null | undefined>;
+    onValueItemChanged?: PropertyChanged<ItemContext<V, D> | null | undefined>;
+    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>, 'data' | 'disabled' | 'displayOptions' | 'help' | 'helpHints' | 'messagesCustom' | 'readonly' | 'required' | 'requiredMessageDetail' | 'userAssistanceDensity' | 'value' | 'valueItem' | 'virtualKeyboard'>;
+    private busyContextRef;
+    private selectSingleRef;
+    private rootRef;
+    componentDidMount(): void;
+    render(props: ExtendGlobalProps<Props<V, D>>): import("preact").JSX.Element;
+    componentWillUnmount(): void;
+    reset(): void;
+    showMessages(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+    blur(): void;
+    focus(): void;
+}
+export declare 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> {
+    readonly valid?: Parameters<Required<Props<V, D>>['onValidChanged']>[0];
+    addEventListener<T extends keyof CSelectSingleElementEventMap<V, D>>(type: T, listener: (this: HTMLElement, ev: CSelectSingleElementEventMap<V, D>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CSelectSingleElementSettableProperties<V, D>>(property: T): CSelectSingleElement<V, D>[T];
+    getProperty(property: string): any;
+    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;
+    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'];
+}
+export namespace CSelectSingleElement {
+    interface ojValueAction<V extends string | number, D extends Record<string, any>> extends CustomEvent<ValueActionPayload<V, D> & {}> {
+    }
+    type containerReadonlyChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['containerReadonly']>;
+    type dataChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['data']>;
+    type disabledChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['disabled']>;
+    type displayOptionsChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['displayOptions']>;
+    type helpChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['help']>;
+    type helpHintsChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['helpHints']>;
+    type itemTextChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['itemText']>;
+    type labelEdgeChanged<V extends string | number, D extends Record<string, any>> = JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelEdge']>;
+    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 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 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']>;
+}
+export interface CSelectSingleElementEventMap<V extends string | number, D extends Record<string, any>> extends HTMLElementEventMap {
+    'ojValueAction': CSelectSingleElement.ojValueAction<V, D>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['containerReadonly']>;
+    'dataChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['data']>;
+    'disabledChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['helpHints']>;
+    'itemTextChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['itemText']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['labelWrapping']>;
+    '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']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['valid']>;
+    'valueChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['value']>;
+    'valueItemChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['valueItem']>;
+    'virtualKeyboardChanged': JetElementCustomEventStrict<CSelectSingleElement<V, D>['virtualKeyboard']>;
+}
+export interface CSelectSingleElementSettableProperties<V extends string | number, D extends Record<string, any>> extends JetSettableProperties {
+    containerReadonly?: Props<V, D>['containerReadonly'];
+    data?: Props<V, D>['data'];
+    disabled?: Props<V, D>['disabled'];
+    displayOptions?: Props<V, D>['displayOptions'];
+    help?: Props<V, D>['help'];
+    helpHints?: Props<V, D>['helpHints'];
+    itemText: Props<V, D>['itemText'];
+    labelEdge?: Props<V, D>['labelEdge'];
+    labelHint: Props<V, D>['labelHint'];
+    labelStartWidth?: Props<V, D>['labelStartWidth'];
+    labelWrapping?: Props<V, D>['labelWrapping'];
+    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'];
+    userAssistanceDensity?: Props<V, D>['userAssistanceDensity'];
+    value?: Props<V, D>['value'];
+    valueItem?: Props<V, D>['valueItem'];
+    virtualKeyboard?: Props<V, D>['virtualKeyboard'];
+}
+export interface CSelectSingleElementSettablePropertiesLenient<V extends string | number, D extends Record<string, any>> extends Partial<CSelectSingleElementSettableProperties<V, D>> {
+    [key: string]: any;
+}
+export interface SelectSingleIntrinsicProps extends Partial<Readonly<CSelectSingleElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    valid?: never;
+    onojValueAction?: (value: CSelectSingleElementEventMap<any, any>['ojValueAction']) => void;
+    oncontainerReadonlyChanged?: (value: CSelectSingleElementEventMap<any, any>['containerReadonlyChanged']) => void;
+    ondataChanged?: (value: CSelectSingleElementEventMap<any, any>['dataChanged']) => void;
+    ondisabledChanged?: (value: CSelectSingleElementEventMap<any, any>['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CSelectSingleElementEventMap<any, any>['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CSelectSingleElementEventMap<any, any>['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CSelectSingleElementEventMap<any, any>['helpHintsChanged']) => void;
+    onitemTextChanged?: (value: CSelectSingleElementEventMap<any, any>['itemTextChanged']) => void;
+    onlabelEdgeChanged?: (value: CSelectSingleElementEventMap<any, any>['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CSelectSingleElementEventMap<any, any>['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CSelectSingleElementEventMap<any, any>['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CSelectSingleElementEventMap<any, any>['labelWrappingChanged']) => 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;
+    onuserAssistanceDensityChanged?: (value: CSelectSingleElementEventMap<any, any>['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CSelectSingleElementEventMap<any, any>['validChanged']) => void;
+    onvalueChanged?: (value: CSelectSingleElementEventMap<any, any>['valueChanged']) => void;
+    onvalueItemChanged?: (value: CSelectSingleElementEventMap<any, any>['valueItemChanged']) => void;
+    onvirtualKeyboardChanged?: (value: CSelectSingleElementEventMap<any, any>['virtualKeyboardChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-select-single': SelectSingleIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+import { ValueUpdateDetail } from '@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail';
+import { ComponentProps } from 'preact';
+import type { SelectSingle } from './select-single';
+declare type SelectSingleProps = ComponentProps<typeof SelectSingle>;
+export declare function useSelectSinglePreact({ data: propData, disabled, displayOptions, itemText, labelEdge, labelHint, labelStartWidth, messagesCustom, placeholder, readonly, required, textAlign, userAssistanceDensity, value: propValue, valueItem: propValueItem, virtualKeyboard, onMessagesCustomChanged, onOjValueAction, onValidChanged, onValueChanged, onValueItemChanged, ...otherProps }: SelectSingleProps, addBusyState: (desc?: string) => () => void): {
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    selectSingleProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        data?: import("@oracle/oraclejet-preact/UNSAFE_Collection").DataState<string | number, Record<string, any>> | null | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isLoading?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        itemText: import("@oracle/oraclejet-preact/utils/UNSAFE_selectUtils").ItemTextType<string | number, Record<string, any>>;
+        label: string;
+        labelEdge?: "start" | "none" | "top" | "inside" | undefined;
+        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
+        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        placeholder?: string | undefined;
+        textAlign?: "start" | "right" | "end" | undefined;
+        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        valueItem?: import("@oracle/oraclejet-preact/utils/UNSAFE_dataProvider").Item<string | number, Record<string, any>> | undefined;
+        variant?: "default" | "embedded" | undefined;
+        virtualKeyboard?: "number" | "text" | "auto" | "search" | "email" | "tel" | "url" | undefined;
+        onCommit: (detail: ValueUpdateDetail<string | number>) => void;
+        onFilter?: (({ searchText }: {
+            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;
+    };
+};
+export {};

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

@@ -0,0 +1,17 @@
+import { Optional } from 'oj-c/select-common/utils/utils';
+import { ItemContext } from 'ojs/ojcommontypes';
+import { DataProvider } from 'ojs/ojdataprovider';
+import { StateUpdater } from 'preact/hooks';
+declare type Value<K> = Optional<K>;
+declare type ValueItem<K, D> = Optional<ItemContext<K, D>>;
+export declare type UseSyncValueAndValueItemProps<K, D> = {
+    addBusyState: (desc?: string) => () => void;
+    dataProvider?: Optional<DataProvider<K, D>>;
+    setIsLoading: StateUpdater<boolean>;
+    setValue: StateUpdater<Value<K>>;
+    setValueItem: (value: ValueItem<K, D>) => void;
+    value?: Value<K>;
+    valueItem?: ValueItem<K, D>;
+};
+export declare function useSyncValueAndValueItem<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setIsLoading, setValue, setValueItem, value, valueItem }: UseSyncValueAndValueItemProps<K, D>): void;
+export {};

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

@@ -0,0 +1,5 @@
+import { PropertyChanged } from 'ojs/ojvcomponent';
+export declare function useValueItem<V>(propValueItem?: V | null, onValueItemsChanged?: PropertyChanged<V | null | undefined>): {
+    valueItem: V | null | undefined;
+    setValueItem: (value: V | null, ...args: any[]) => void;
+};

package/oj-c/types/split-menu-button/__tests__/split-menu-button.test.d.ts

@@ -0,0 +1 @@
+export {};

package/oj-c/types/split-menu-button/index.d.ts

@@ -0,0 +1,2 @@
+export { SplitMenuButton, SplitMenuButtonMenuItem, SplitMenuButtonMenuItemType } from './split-menu-button';
+export { CSplitMenuButtonElement } from './split-menu-button';