@oracle/oraclejet-core-pack 17.1.4 → 18.0.1

package/oj-c/types/line-chart/line-chart.d.ts

@@ -5,14 +5,35 @@ import { ComponentProps, ComponentType } from 'preact';
 import { LineAreaChart as PreactLineChart } from '@oracle/oraclejet-preact/UNSAFE_LineAreaChart';
 import { LineChartItemProps } from '../line-chart-item/line-chart-item';
 import 'css!oj-c/line-chart/line-chart-styles.css';
-import { Action, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
+import { Action, Bubbles, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
 import { ChartItemTemplateContext, ChartSeriesTemplateContext, ChartGroupTemplateContext } from '../hooks/UNSAFE_useChartData/useChartData';
 import { Group } from '@oracle/oraclejet-preact/utils/UNSAFE_visTypes/chart';
 import type { ViewPortDetail, PlotArea, YAxis, XAxis, ValueFormats } from '../utils/UNSAFE_vizTypes/chartTypes';
 import type { ChartLegend } from '../utils/UNSAFE_vizTypes';
 import { DataProvider } from 'ojs/ojdataprovider';
 import { LineChartSeriesProps } from 'oj-c/line-chart-series/line-chart-series';
+import { type ContextMenuConfig, type ContextMenuSelectionDetail, type ContextMenuActionDetail } from 'oj-c/hooks/PRIVATE_useVisContextMenu/useVisContextMenu';
+import { AreaChartSeries } from 'oj-c/area-chart/area-chart';
 type PreactLineChartProps = ComponentProps<typeof PreactLineChart>;
+export type LineChartContextMenuConfig<K, D> = ContextMenuConfig<LineContextMenuContext<K, D>>;
+export type LineChartContextMenuSelectionDetail<K, D> = ContextMenuSelectionDetail<LineContextMenuContext<K, D>>;
+export type LineChartContextMenuActionDetail<K, D> = ContextMenuActionDetail<LineContextMenuContext<K, D>>;
+export type LineContextMenuContext<K, D> = {
+    data?: LineItem<K>;
+    itemData?: D;
+    type: 'item';
+} | {
+    type: 'background';
+} | {
+    type: 'xAxisTickLabel';
+    data: Group;
+} | {
+    type: 'series';
+    data: AreaChartSeries<K>;
+} | {
+    type: 'axisTitle';
+    axis: 'x' | 'y';
+};
 export type LineItem<K> = {
     id: K;
 } & LineChartItemProps;
@@ -72,8 +93,11 @@ export type LineChartProps<K, D extends LineItem<K> | any> = ObservedGlobalProps
     hoverBehavior?: 'dim' | 'none';
     highlightMatch?: 'any' | 'all';
     legend?: ChartLegend;
+    contextMenuConfig?: LineChartContextMenuConfig<K, D>;
+    onOjContextMenuAction?: Action<LineChartContextMenuActionDetail<K, D>> & Bubbles;
+    onOjContextMenuSelection?: Action<LineChartContextMenuSelectionDetail<K, D>> & Bubbles;
 };
-declare function LineChartComp<K extends string | number, D extends LineItem<K> | any>({ data, hideAndShowBehavior, orientation, xAxis, yAxis, hoverBehavior, valueFormats, plotArea, zoomAndScroll, itemTemplate, seriesTemplate, groupTemplate, seriesComparator, groupComparator, drilling, hiddenCategories, timeAxisType, highlightedCategories, highlightMatch, selection, selectionMode, stack, legend, ...props }: LineChartProps<K, D>): import("preact").JSX.Element;
+declare function LineChartComp<K extends string | number, D extends LineItem<K> | any>({ data, hideAndShowBehavior, orientation, xAxis, yAxis, hoverBehavior, valueFormats, plotArea, zoomAndScroll, itemTemplate, seriesTemplate, groupTemplate, seriesComparator, groupComparator, drilling, hiddenCategories, timeAxisType, highlightedCategories, highlightMatch, selection, selectionMode, stack, legend, contextMenuConfig, onOjContextMenuAction, onOjContextMenuSelection, ...props }: LineChartProps<K, D>): import("preact").JSX.Element;
 export declare const LineChart: ComponentType<ExtendGlobalProps<ComponentProps<typeof LineChartComp>>>;
 export {};
 export interface CLineChartElement<K extends string | number, D extends LineItem<K> | any> extends JetElement<CLineChartElementSettableProperties<K, D>>, CLineChartElementSettableProperties<K, D> {
@@ -94,6 +118,11 @@ export namespace CLineChartElement {
     }
     interface ojViewportChange extends CustomEvent<ViewPortDetail & {}> {
     }
+    interface ojContextMenuAction<K extends string | number, D extends LineItem<K> | any> extends CustomEvent<LineChartContextMenuActionDetail<K, D> & {}> {
+    }
+    interface ojContextMenuSelection<K extends string | number, D extends LineItem<K> | any> extends CustomEvent<LineChartContextMenuSelectionDetail<K, D> & {}> {
+    }
+    type contextMenuConfigChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['contextMenuConfig']>;
     type dataChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['data']>;
     type dragModeChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['dragMode']>;
     type drillingChanged<K extends string | number, D extends LineItem<K> | any> = JetElementCustomEventStrict<CLineChartElement<K, D>['drilling']>;
@@ -124,6 +153,9 @@ export interface CLineChartElementEventMap<K extends string | number, D extends
     'ojSeriesDrill': CLineChartElement.ojSeriesDrill<K>;
     'ojGroupDrill': CLineChartElement.ojGroupDrill<K>;
     'ojViewportChange': CLineChartElement.ojViewportChange;
+    'ojContextMenuAction': CLineChartElement.ojContextMenuAction<K, D>;
+    'ojContextMenuSelection': CLineChartElement.ojContextMenuSelection<K, D>;
+    'contextMenuConfigChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['contextMenuConfig']>;
     'dataChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['data']>;
     'dragModeChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['dragMode']>;
     'drillingChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['drilling']>;
@@ -147,6 +179,7 @@ export interface CLineChartElementEventMap<K extends string | number, D extends
     'zoomAndScrollChanged': JetElementCustomEventStrict<CLineChartElement<K, D>['zoomAndScroll']>;
 }
 export interface CLineChartElementSettableProperties<K, D extends LineItem<K> | any> extends JetSettableProperties {
+    contextMenuConfig?: LineChartProps<K, D>['contextMenuConfig'];
     data?: LineChartProps<K, D>['data'];
     dragMode?: LineChartProps<K, D>['dragMode'];
     drilling?: LineChartProps<K, D>['drilling'];
@@ -174,10 +207,13 @@ export interface CLineChartElementSettablePropertiesLenient<K, D extends LineIte
 }
 export interface LineChartIntrinsicProps extends Partial<Readonly<CLineChartElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
     children?: import('preact').ComponentChildren;
+    onojContextMenuAction?: (value: CLineChartElementEventMap<any, any>['ojContextMenuAction']) => void;
+    onojContextMenuSelection?: (value: CLineChartElementEventMap<any, any>['ojContextMenuSelection']) => void;
     onojGroupDrill?: (value: CLineChartElementEventMap<any, any>['ojGroupDrill']) => void;
     onojItemDrill?: (value: CLineChartElementEventMap<any, any>['ojItemDrill']) => void;
     onojSeriesDrill?: (value: CLineChartElementEventMap<any, any>['ojSeriesDrill']) => void;
     onojViewportChange?: (value: CLineChartElementEventMap<any, any>['ojViewportChange']) => void;
+    oncontextMenuConfigChanged?: (value: CLineChartElementEventMap<any, any>['contextMenuConfigChanged']) => void;
     ondataChanged?: (value: CLineChartElementEventMap<any, any>['dataChanged']) => void;
     ondragModeChanged?: (value: CLineChartElementEventMap<any, any>['dragModeChanged']) => void;
     ondrillingChanged?: (value: CLineChartElementEventMap<any, any>['drillingChanged']) => void;

package/oj-c/types/list-item-layout/list-item-layout.d.ts

@@ -17,8 +17,8 @@ export declare const ListItemLayout: import("preact").ComponentType<import("ojs/
     action?: Slot;
     quaternary?: Slot;
     navigation?: Slot;
-    inset?: "none" | "listInset" | undefined;
-    verticalAlignment?: "top" | "middle" | undefined;
+    inset?: "none" | "listInset";
+    verticalAlignment?: "middle" | "top";
 }>>;
 export interface CListItemLayoutElement extends JetElement<CListItemLayoutElementSettableProperties>, CListItemLayoutElementSettableProperties {
     addEventListener<T extends keyof CListItemLayoutElementEventMap>(type: T, listener: (this: HTMLElement, ev: CListItemLayoutElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;

package/oj-c/types/list-view/list-view.d.ts

@@ -5,7 +5,7 @@ import { DataProvider, Item } from 'ojs/ojdataprovider';
 import { ImmutableKeySet } from 'ojs/ojkeyset';
 import { Action, Bubbles, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
 import { ComponentProps, ComponentType } from 'preact';
-import { ListView as PreactListView } from '@oracle/oraclejet-preact/UNSAFE_ListView';
+import { ListView as PreactListView, ItemPadding } from '@oracle/oraclejet-preact/UNSAFE_ListView';
 import 'css!oj-c/list-view/list-view-styles.css';
 import { ContextMenuItems } from '../utils/PRIVATE_ItemsMenu/items-menu';
 type PreactListViewProps = ComponentProps<typeof PreactListView>;
@@ -43,6 +43,9 @@ export type ReorderDetail<K> = {
 type selectionMode = PreactListViewProps['selectionMode'] | 'singleRequired';
 type Props<K extends string | number, D> = ObservedGlobalProps<'aria-label' | 'aria-labelledby' | 'id'> & {
     onCurrentItemChanged?: ReadOnlyPropertyChanged<K>;
+    currentItemOverride?: {
+        rowKey: K;
+    };
     data?: DataProvider<K, D> | null;
     gridlines?: PreactListViewProps['gridlines'];
     itemTemplate?: TemplateSlot<ListItemContext<K, D>>;
@@ -63,8 +66,11 @@ type Props<K extends string | number, D> = ObservedGlobalProps<'aria-label' | 'a
         items?: 'enabled' | 'disabled';
     };
     onOjReorder?: Action<ReorderDetail<K>>;
+    item?: {
+        padding?: 'disabled' | 'enabled' | ItemPadding;
+    };
 };
-declare const ListViewImpl: <K extends string | number, D>({ selectionMode, reorderable, ...rest }: Props<K, D>) => import("preact").JSX.Element;
+declare const ListViewImpl: <K extends string | number, D>({ selectionMode, reorderable, item, ...rest }: Props<K, D>) => import("preact").JSX.Element;
 export declare const ListView: ComponentType<ExtendGlobalProps<ComponentProps<typeof ListViewImpl<string | number, any>>>>;
 export type ListViewProps<K extends string | number, D> = Props<K, D>;
 export {};
@@ -91,8 +97,10 @@ export namespace CListViewElement {
     }
     type contextMenuConfigChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['contextMenuConfig']>;
     type currentItemChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['currentItem']>;
+    type currentItemOverrideChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['currentItemOverride']>;
     type dataChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['data']>;
     type gridlinesChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['gridlines']>;
+    type itemChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['item']>;
     type reorderableChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['reorderable']>;
     type scrollPolicyOptionsChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['scrollPolicyOptions']>;
     type selectedChanged<K extends string | number, D> = JetElementCustomEventStrict<CListViewElement<K, D>['selected']>;
@@ -108,8 +116,10 @@ export interface CListViewElementEventMap<K extends string | number, D> extends
     'ojReorder': CListViewElement.ojReorder<K>;
     'contextMenuConfigChanged': JetElementCustomEventStrict<CListViewElement<K, D>['contextMenuConfig']>;
     'currentItemChanged': JetElementCustomEventStrict<CListViewElement<K, D>['currentItem']>;
+    'currentItemOverrideChanged': JetElementCustomEventStrict<CListViewElement<K, D>['currentItemOverride']>;
     'dataChanged': JetElementCustomEventStrict<CListViewElement<K, D>['data']>;
     'gridlinesChanged': JetElementCustomEventStrict<CListViewElement<K, D>['gridlines']>;
+    'itemChanged': JetElementCustomEventStrict<CListViewElement<K, D>['item']>;
     'reorderableChanged': JetElementCustomEventStrict<CListViewElement<K, D>['reorderable']>;
     'scrollPolicyOptionsChanged': JetElementCustomEventStrict<CListViewElement<K, D>['scrollPolicyOptions']>;
     'selectedChanged': JetElementCustomEventStrict<CListViewElement<K, D>['selected']>;
@@ -117,8 +127,10 @@ export interface CListViewElementEventMap<K extends string | number, D> extends
 }
 export interface CListViewElementSettableProperties<K extends string | number, D> extends JetSettableProperties {
     contextMenuConfig?: Props<K, D>['contextMenuConfig'];
+    currentItemOverride?: Props<K, D>['currentItemOverride'];
     data?: Props<K, D>['data'];
     gridlines?: Props<K, D>['gridlines'];
+    item?: Props<K, D>['item'];
     reorderable?: Props<K, D>['reorderable'];
     scrollPolicyOptions?: Props<K, D>['scrollPolicyOptions'];
     selected?: Props<K, D>['selected'];
@@ -137,8 +149,10 @@ export interface ListViewIntrinsicProps extends Partial<Readonly<CListViewElemen
     onojReorder?: (value: CListViewElementEventMap<any, any>['ojReorder']) => void;
     oncontextMenuConfigChanged?: (value: CListViewElementEventMap<any, any>['contextMenuConfigChanged']) => void;
     oncurrentItemChanged?: (value: CListViewElementEventMap<any, any>['currentItemChanged']) => void;
+    oncurrentItemOverrideChanged?: (value: CListViewElementEventMap<any, any>['currentItemOverrideChanged']) => void;
     ondataChanged?: (value: CListViewElementEventMap<any, any>['dataChanged']) => void;
     ongridlinesChanged?: (value: CListViewElementEventMap<any, any>['gridlinesChanged']) => void;
+    onitemChanged?: (value: CListViewElementEventMap<any, any>['itemChanged']) => void;
     onreorderableChanged?: (value: CListViewElementEventMap<any, any>['reorderableChanged']) => void;
     onscrollPolicyOptionsChanged?: (value: CListViewElementEventMap<any, any>['scrollPolicyOptionsChanged']) => void;
     onselectedChanged?: (value: CListViewElementEventMap<any, any>['selectedChanged']) => void;

package/oj-c/types/list-view/useCurrentItemOverride.d.ts

@@ -0,0 +1,6 @@
+import { Item as CurrentItem } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { ListViewProps } from './list-view';
+export declare const useCurrentItemOverride: <K extends string | number, D>(currentItemOverride: ListViewProps<K, D>["currentItemOverride"]) => {
+    preactCurrentItemOverride: CurrentItem<K> | undefined;
+    updateCurrentItemOverride: (key: K) => void;
+};

package/oj-c/types/list-view/useHandleRemoveCurrentKey.d.ts

@@ -1,4 +1,4 @@
-import { DataState, CurrentItemDetail } from '@oracle/oraclejet-preact/UNSAFE_Collection';
+import { DataState, CurrentKeyDetail } from '@oracle/oraclejet-preact/UNSAFE_Collection';
 export declare function useHandleRemoveCurrentKey<K, D>(dataState: DataState<K, D> | null, updateCurrentKey: (key: K) => void): {
-    notifyCurrentItemChanged: (detail: CurrentItemDetail<K>) => void;
+    notifyCurrentKeyChanged: (detail: CurrentKeyDetail<K>) => void;
 };

package/oj-c/types/list-view/useListViewPreact.d.ts

@@ -1,13 +1,9 @@
+import { ComponentProps } from 'preact';
+import { ListView as PreactListView } from '@oracle/oraclejet-preact/UNSAFE_ListView';
 import { ListViewProps } from './list-view';
-export declare const useListViewPreact: <K extends string | number, D>({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, data: propData, gridlines, onCurrentItemChanged, selectionMode, selected, scrollPolicyOptions, onSelectedChanged, onOjItemAction, onOjFirstSelectedItem, reorderable, onOjReorder }: Partial<ListViewProps<K, D>>, addBusyState: (desc?: string) => () => void, isClickthroughDisabled: (target: EventTarget | null) => boolean) => {
+type PreactListViewProps = ComponentProps<typeof PreactListView>;
+export declare const useListViewPreact: <K extends string | number, D>({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, data: propData, gridlines, currentItemOverride, onCurrentItemChanged, selectionMode, selected, scrollPolicyOptions, onSelectedChanged, onOjItemAction, onOjFirstSelectedItem, reorderable, onOjReorder, item }: Partial<ListViewProps<K, D>>, addBusyState: (desc?: string) => () => void, isClickthroughDisabled: (target: EventTarget | null) => boolean) => {
     status: "error" | "loading" | "success";
-    listViewProps: Pick<import("@oracle/oraclejet-preact/UNSAFE_ListView").Props<string | number, unknown>, "children" | "aria-label" | "aria-labelledby" | "testId" | "selectionMode" | "onSelectionChange" | "onItemAction" | "selectedKeys" | "viewportConfig" | "gridlines" | "currentItemVariant" | "currentItemOverride" | "onPersistCurrentItem" | "promotedSection" | "scrollPositionOverride" | "onReorder"> & {
-        data: unknown[] | null;
-        getRowKey: (data: unknown) => string | number;
-        hasMore?: boolean | undefined;
-        onLoadMore?: (() => void) | undefined;
-        contextMenuConfig?: import("@oracle/oraclejet-preact/UNSAFE_ListView/List.types").ListViewContextMenuConfig<string | number, unknown> | undefined;
-    } & {
-        ref?: import("preact/compat").ForwardedRef<import("@oracle/oraclejet-preact/UNSAFE_ListView").ListViewHandle<string | number>> | undefined;
-    };
+    listViewProps: PreactListViewProps;
 };
+export {};

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

@@ -4,16 +4,17 @@ import 'ojs/oj-jsx-interfaces';
 import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, Slot, Action, Bubbles } from 'ojs/ojvcomponent';
 import { MenuButton as PreactMenuButton } from '@oracle/oraclejet-preact/UNSAFE_MenuButton';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
-import { ItemsMenu, MenuItemSelectionDetail, MenuItems } from 'oj-c/utils/PRIVATE_ItemsMenu/items-menu';
+import { ItemsMenu, MenuItemSelectionDetail, SelectMenuItemDetail, MenuSelection, MenuItems } from 'oj-c/utils/PRIVATE_ItemsMenu/items-menu';
 export type { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
-export type { MenuSelection, MenuItems, MenuItemSelectionDetail } from 'oj-c/utils/PRIVATE_ItemsMenu/items-menu';
+export type { MenuSelection, MenuItems, MenuItemSelectionDetail, SelectMenuItemDetail } from 'oj-c/utils/PRIVATE_ItemsMenu/items-menu';
 export type PreactMenuButtonProps = ComponentProps<typeof PreactMenuButton>;
-import { ComponentProps, Component } from 'preact';
+import { ComponentProps, Ref, ComponentType } from 'preact';
 import 'css!oj-c/menu-button/menu-button-styles.css';
 type ItemsMenuProps = ComponentProps<typeof ItemsMenu>;
 type ItemsMenuButtonProps = {
     items: MenuItems[];
 };
+type MenuButtonMenuSelectionDetail = SelectMenuItemDetail<MenuSelection>;
 type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
     label: string;
     suffix?: string;
@@ -22,6 +23,7 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
     endIcon?: Slot;
     items?: ItemsMenuButtonProps['items'];
     onOjMenuAction?: Action<MenuItemSelectionDetail> & Bubbles;
+    onOjMenuSelection?: Action<MenuButtonMenuSelectionDetail> & Bubbles;
     selection?: ItemsMenuProps['selection'];
     onSelectionChanged?: PropertyChanged<ItemsMenuProps['selection']>;
     display?: 'all' | 'icons' | 'label';
@@ -30,14 +32,13 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
     width?: Size;
     chroming?: PreactMenuButtonProps['variant'];
 };
-export declare class MenuButton extends Component<ExtendGlobalProps<Props>> {
-    static defaultProps: Partial<Props>;
-    private buttonRef;
-    render({ chroming, label, tooltip, disabled, suffix, size, items, display, startIcon, endIcon, selection, onSelectionChanged, onOjMenuAction, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy, width }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
-    private OverFlowIcon;
-    blur(): void;
-    focus(): void;
-}
+type MenuButtonHandle = {
+    focus: () => void;
+    blur: () => void;
+    click: () => void;
+};
+declare function MenuButtonImpl({ label, chroming, disabled, size, display, items, tooltip, suffix, startIcon, endIcon, selection, onSelectionChanged, onOjMenuAction, onOjMenuSelection, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy, width }: Props, ref: Ref<MenuButtonHandle>): import("preact").JSX.Element;
+export declare const MenuButton: ComponentType<ExtendGlobalProps<ComponentProps<typeof MenuButtonImpl>>>;
 export interface CMenuButtonElement extends JetElement<CMenuButtonElementSettableProperties>, CMenuButtonElementSettableProperties {
     addEventListener<T extends keyof CMenuButtonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CMenuButtonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
@@ -46,12 +47,15 @@ export interface CMenuButtonElement extends JetElement<CMenuButtonElementSettabl
     setProperty<T extends keyof CMenuButtonElementSettableProperties>(property: T, value: CMenuButtonElementSettableProperties[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CMenuButtonElementSettableProperties>): void;
     setProperties(properties: CMenuButtonElementSettablePropertiesLenient): void;
-    blur: MenuButton['blur'];
-    focus: MenuButton['focus'];
+    blur: () => void;
+    click: () => void;
+    focus: () => void;
 }
 export namespace CMenuButtonElement {
     interface ojMenuAction extends CustomEvent<MenuItemSelectionDetail & {}> {
     }
+    interface ojMenuSelection extends CustomEvent<MenuButtonMenuSelectionDetail & {}> {
+    }
     type chromingChanged = JetElementCustomEventStrict<CMenuButtonElement['chroming']>;
     type disabledChanged = JetElementCustomEventStrict<CMenuButtonElement['disabled']>;
     type displayChanged = JetElementCustomEventStrict<CMenuButtonElement['display']>;
@@ -65,6 +69,7 @@ export namespace CMenuButtonElement {
 }
 export interface CMenuButtonElementEventMap extends HTMLElementEventMap {
     'ojMenuAction': CMenuButtonElement.ojMenuAction;
+    'ojMenuSelection': CMenuButtonElement.ojMenuSelection;
     'chromingChanged': JetElementCustomEventStrict<CMenuButtonElement['chroming']>;
     'disabledChanged': JetElementCustomEventStrict<CMenuButtonElement['disabled']>;
     'displayChanged': JetElementCustomEventStrict<CMenuButtonElement['display']>;
@@ -94,6 +99,7 @@ export interface CMenuButtonElementSettablePropertiesLenient extends Partial<CMe
 export interface MenuButtonIntrinsicProps extends Partial<Readonly<CMenuButtonElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
     children?: import('preact').ComponentChildren;
     onojMenuAction?: (value: CMenuButtonElementEventMap['ojMenuAction']) => void;
+    onojMenuSelection?: (value: CMenuButtonElementEventMap['ojMenuSelection']) => void;
     onchromingChanged?: (value: CMenuButtonElementEventMap['chromingChanged']) => void;
     ondisabledChanged?: (value: CMenuButtonElementEventMap['disabledChanged']) => void;
     ondisplayChanged?: (value: CMenuButtonElementEventMap['displayChanged']) => void;

package/oj-c/types/meter-bar/meter-bar.d.ts

@@ -15,26 +15,26 @@ export type ThresholdDisplay = 'all' | 'plotArea' | 'indicator';
 type DatatipContext = {
     value: number;
 };
-export declare const MeterBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label" | "aria-labelledby" | "aria-describedby"> & {
-    max?: number | undefined;
-    min?: number | undefined;
-    readonly?: boolean | undefined;
-    value?: number | null | undefined;
-    baseline?: number | undefined;
-    onValueChanged?: PropertyChanged<number | null> | undefined;
-    step?: number | undefined;
-    color?: PreactMeterBarProps['indicatorColor'];
-    indicatorSize?: number | undefined;
-    plotArea?: PlotArea | undefined;
-    orientation?: PreactMeterBarProps['orientation'];
-    referenceLines?: ReferenceLine[] | undefined;
-    thresholdDisplay?: ThresholdDisplay | undefined;
-    thresholds?: Threshold[] | undefined;
-    describedBy?: string | null | undefined;
-    labelledBy?: string | null | undefined;
-    size?: PreactMeterBarProps['size'];
-    datatip?: ((context: DatatipContext) => string | null) | undefined;
-    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
+export declare const MeterBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-describedby" | "aria-label" | "aria-labelledby"> & {
+    max?: number;
+    min?: number;
+    readonly?: boolean;
+    value?: number | null;
+    baseline?: number;
+    onValueChanged?: PropertyChanged<number | null>;
+    step?: number;
+    color?: PreactMeterBarProps["indicatorColor"];
+    indicatorSize?: number;
+    plotArea?: PlotArea;
+    orientation?: PreactMeterBarProps["orientation"];
+    referenceLines?: Array<ReferenceLine>;
+    thresholdDisplay?: ThresholdDisplay;
+    thresholds?: Array<Threshold>;
+    describedBy?: string | null;
+    labelledBy?: string | null;
+    size?: PreactMeterBarProps["size"];
+    datatip?: (context: DatatipContext) => string | null;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined>;
 }>>;
 export {};
 export interface CMeterBarElement extends JetElement<CMeterBarElementSettableProperties>, CMeterBarElementSettableProperties {

package/oj-c/types/meter-circle/meter-circle.d.ts

@@ -8,7 +8,7 @@ import 'css!oj-c/meter-circle/meter-circle-styles.css';
 import { ReferenceLine as CommonReferenceLine, Threshold } from '../utils/UNSAFE_vizTypes';
 type ReferenceLine = Omit<CommonReferenceLine, 'position'>;
 type PreactMeterCircleProps = ComponentProps<typeof PreactMeterCircle>;
-export type Context = CenterContext & {
+type CenterTemplateContext = CenterContext & {
     value: number | null;
 };
 type PlotArea = {
@@ -19,28 +19,28 @@ export type DatatipContext = {
     value: number;
 };
 export type ThresholdDisplay = 'all' | 'plotArea' | 'indicator';
-export declare const MeterCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label" | "aria-labelledby" | "aria-describedby"> & {
-    max?: number | undefined;
-    min?: number | undefined;
-    readonly?: boolean | undefined;
-    value?: number | null | undefined;
-    onValueChanged?: PropertyChanged<number | null> | undefined;
-    step?: number | undefined;
-    color?: PreactMeterCircleProps['indicatorColor'];
-    indicatorSize?: number | undefined;
+export declare const MeterCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-describedby" | "aria-label" | "aria-labelledby"> & {
+    max?: number;
+    min?: number;
+    readonly?: boolean;
+    value?: number | null;
+    onValueChanged?: PropertyChanged<number | null>;
+    step?: number;
+    color?: PreactMeterCircleProps["indicatorColor"];
+    indicatorSize?: number;
     innerRadius?: number | undefined;
     plotArea: PlotArea;
-    angleExtent?: PreactMeterCircleProps['angleExtent'];
-    startAngle?: PreactMeterCircleProps['startAngle'];
-    referenceLines?: ReferenceLine[] | undefined;
-    thresholdDisplay?: ThresholdDisplay | undefined;
-    thresholds?: Threshold[] | undefined;
-    describedBy?: string | null | undefined;
-    labelledBy?: string | null | undefined;
-    size?: PreactMeterCircleProps['size'];
-    datatip?: ((context: DatatipContext) => string | null) | undefined;
-    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
-    centerTemplate?: TemplateSlot<Context> | undefined;
+    angleExtent?: PreactMeterCircleProps["angleExtent"];
+    startAngle?: PreactMeterCircleProps["startAngle"];
+    referenceLines?: Array<ReferenceLine>;
+    thresholdDisplay?: ThresholdDisplay;
+    thresholds?: Array<Threshold>;
+    describedBy?: string | null;
+    labelledBy?: string | null;
+    size?: PreactMeterCircleProps["size"];
+    datatip?: (context: DatatipContext) => string | null;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined>;
+    centerTemplate?: TemplateSlot<CenterTemplateContext>;
 }>>;
 export {};
 export interface CMeterCircleElement extends JetElement<CMeterCircleElementSettableProperties>, CMeterCircleElementSettableProperties {
@@ -73,7 +73,7 @@ export namespace CMeterCircleElement {
     type thresholdsChanged = JetElementCustomEventStrict<CMeterCircleElement['thresholds']>;
     type transientValueChanged = JetElementCustomEventStrict<CMeterCircleElement['transientValue']>;
     type valueChanged = JetElementCustomEventStrict<CMeterCircleElement['value']>;
-    type RenderCenterTemplate = import('ojs/ojvcomponent').TemplateSlot<Context>;
+    type RenderCenterTemplate = import('ojs/ojvcomponent').TemplateSlot<CenterTemplateContext>;
 }
 export interface CMeterCircleElementEventMap extends HTMLElementEventMap {
     'angleExtentChanged': JetElementCustomEventStrict<CMeterCircleElement['angleExtent']>;

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

@@ -5,14 +5,10 @@ import { ExtendGlobalProps, PropertyChanged, Action, CancelableAction, ObservedG
 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 { Coords, Offset } 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'> & {
+export type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'aria-labelledby' | 'id'> & {
     children?: ComponentChildren;
     opened: boolean;
     launcher?: string | Element;
@@ -22,7 +18,7 @@ export type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label' | 'ari
     autoDismiss?: 'none' | 'focusLoss';
     tail?: Tail;
     initialFocus?: InitialFocus;
-    offset?: PopupOffset;
+    offset?: Offset;
     collision?: PositionCollision;
     onOpenedChanged?: PropertyChanged<boolean>;
     onOjOpen?: Action;

package/oj-c/types/progress-bar/progress-bar.d.ts

@@ -6,10 +6,10 @@ import { ComponentProps } from 'preact';
 import { ObservedGlobalProps } from 'ojs/ojvcomponent';
 import 'css!oj-c/progress-bar/progress-bar-styles.css';
 type PreactProgressBarProps = ComponentProps<typeof PreactProgressBar>;
-export declare const ProgressBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-valuetext"> & {
-    max?: number | undefined;
-    value?: number | undefined;
-    edge?: PreactProgressBarProps['edge'];
+export declare const ProgressBar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label" | "aria-labelledby" | "aria-valuetext"> & {
+    max?: number;
+    value?: number;
+    edge?: PreactProgressBarProps["edge"];
 }>>;
 export {};
 export interface CProgressBarElement extends JetElement<CProgressBarElementSettableProperties>, CProgressBarElementSettableProperties {

package/oj-c/types/progress-circle/progress-circle.d.ts

@@ -6,10 +6,10 @@ import { ComponentProps } from 'preact';
 import { ObservedGlobalProps } from 'ojs/ojvcomponent';
 import 'css!oj-c/progress-circle/progress-circle-styles.css';
 type PreactProgressCircleProps = ComponentProps<typeof PreactProgressCircle>;
-export declare const ProgressCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-valuetext"> & {
-    max?: number | undefined;
-    value?: number | undefined;
-    size?: PreactProgressCircleProps['size'];
+export declare const ProgressCircle: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label" | "aria-labelledby" | "aria-valuetext"> & {
+    max?: number;
+    value?: number;
+    size?: PreactProgressCircleProps["size"];
 }>>;
 export {};
 export interface CProgressCircleElement extends JetElement<CProgressCircleElementSettableProperties>, CProgressCircleElementSettableProperties {

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

@@ -1,29 +1,13 @@
+import { RadioSet as PreactRadioSet } from '@oracle/oraclejet-preact/UNSAFE_RadioSet';
+import { ComponentProps } from 'preact';
 import { RadiosetDataItem, RadiosetProps } from './radioset';
+type PreactRadioSetProps = ComponentProps<typeof PreactRadioSet>;
 export declare function useRadiosetPreact<V extends string | number, D extends RadiosetDataItem>({ direction, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, messagesCustom, readonly, requiredMessageDetail: propRequiredMessageDetail, required, userAssistanceDensity, value: propValue, onMessagesCustomChanged, onValidChanged, onValueChanged, ...otherProps }: RadiosetProps<V, D>, addBusyState: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         showMessages: () => void;
-        validate: () => Promise<"invalid" | "valid">;
-    };
-    radiosetProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
-        'aria-describedby'?: string | undefined;
-        assistiveText?: string | undefined;
-        children: import("preact").ComponentChildren;
-        columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
-        direction?: "row" | "column" | undefined;
-        helpSourceLink?: string | undefined;
-        helpSourceText?: string | undefined;
-        isRequired?: boolean | undefined;
-        isReadonly?: boolean | undefined;
-        isDisabled?: boolean | undefined;
-        label: string;
-        labelEdge?: "none" | "start" | "top" | "inside" | undefined;
-        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
-        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
-        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?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+        validate: () => Promise<"valid" | "invalid">;
     };
+    radiosetProps: PreactRadioSetProps;
 };
+export {};

package/oj-c/types/rating-gauge/rating-gauge.d.ts

@@ -10,23 +10,23 @@ type PreactRatingGaugeProps = ComponentProps<typeof PreactRatingGauge>;
 type DatatipContext = {
     value: number;
 };
-export declare const RatingGauge: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label" | "aria-labelledby" | "aria-describedby"> & {
-    max?: number | undefined;
-    readonly?: boolean | undefined;
-    disabled?: boolean | undefined;
-    changed?: boolean | undefined;
-    onChangedChanged?: PropertyChanged<boolean> | undefined;
-    value?: number | null | undefined;
-    onValueChanged?: PropertyChanged<number | null> | undefined;
-    step?: number | undefined;
-    describedBy?: string | null | undefined;
-    labelledBy?: string | null | undefined;
-    size?: PreactRatingGaugeProps['size'];
-    color?: PreactRatingGaugeProps['color'];
-    thresholds?: Threshold[] | undefined;
-    datatip?: ((context: DatatipContext) => string) | undefined;
-    tooltip?: string | undefined;
-    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined> | undefined;
+export declare const RatingGauge: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-describedby" | "aria-label" | "aria-labelledby"> & {
+    max?: number;
+    readonly?: boolean;
+    disabled?: boolean;
+    changed?: boolean;
+    onChangedChanged?: PropertyChanged<boolean>;
+    value?: number | null;
+    onValueChanged?: PropertyChanged<number | null>;
+    step?: number;
+    describedBy?: string | null;
+    labelledBy?: string | null;
+    size?: PreactRatingGaugeProps["size"];
+    color?: PreactRatingGaugeProps["color"];
+    thresholds?: Array<Threshold>;
+    datatip?: (context: DatatipContext) => string;
+    tooltip?: string;
+    onTransientValueChanged?: ReadOnlyPropertyChanged<number | undefined>;
 }>>;
 export {};
 export interface CRatingGaugeElement extends JetElement<CRatingGaugeElementSettableProperties>, CRatingGaugeElementSettableProperties {

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

@@ -78,6 +78,7 @@ 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;
+    UNSAFE_focusAndOpenDropdown: () => void;
     _selectItemsByValue: (value: Set<K> | null) => Promise<void>;
     blur: () => void;
     focus: () => void;

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

@@ -5,24 +5,24 @@ import type { SelectMultipleProps } from './select-multiple';
 export declare function useSelectMultiplePreact<K extends string | number, D extends Record<string, any>>({ collectionTemplate, data, 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;
+        validate: () => Promise<"valid" | "invalid">;
     };
     selectMultipleProps: {
         'aria-describedby': string | undefined;
-        collectionRenderer: ((collectionRendererProps: import("@oracle/oraclejet-preact/UNSAFE_SelectMultiple/SelectMultiple.types").CollectionRendererProps<K, D>) => import("preact").ComponentChildren) | undefined;
+        collectionRenderer: ((collectionRendererProps: import("@oracle/oraclejet-preact/dist/types/UNSAFE_SelectMultiple/SelectMultiple.types").CollectionRendererProps<K, D>) => import("preact").ComponentChildren) | undefined;
         data: DataState<K, D> | null;
         isDisabled: boolean | undefined;
         isLoading: boolean;
         isReadonly: boolean | undefined;
         isRequired: boolean | undefined;
         isRequiredShown: boolean | undefined;
-        itemRenderer: ((itemRendererProps: import("@oracle/oraclejet-preact/UNSAFE_SelectMultiple/SelectMultiple.types").ItemRendererProps<K, D>) => import("preact").ComponentChildren) | undefined;
+        itemRenderer: ((itemRendererProps: import("@oracle/oraclejet-preact/dist/types/UNSAFE_SelectMultiple/SelectMultiple.types").ItemRendererProps<K, D>) => import("preact").ComponentChildren) | undefined;
         itemText: keyof D | ((itemContext: ItemContext<K, D>) => string);
         label: string;
         labelEdge: "none" | "start" | "top" | "inside" | undefined;
-        labelStartWidth: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
-        messages: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
+        labelStartWidth: import("@oracle/oraclejet-preact/dist/types/utils/UNSAFE_size").Size | undefined;
+        messages: import("@oracle/oraclejet-preact/dist/types/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
         onCommit: ({ value }: ValueUpdateDetail<Set<K>>) => Promise<void>;
         onFilter: ({ searchText }: {
             searchText?: string;
@@ -30,7 +30,7 @@ export declare function useSelectMultiplePreact<K extends string | number, D ext
         onLoadRange: (range: import("@oracle/oraclejet-preact/UNSAFE_Collection").Range) => void;
         placeholder: string | undefined;
         textAlign: "end" | "start" | "right" | undefined;
-        userAssistanceDensity: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
+        userAssistanceDensity: import("@oracle/oraclejet-preact/dist/types/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
         valueItems: ItemContext<K, D>[] | undefined;
         virtualKeyboard: "number" | "search" | "auto" | "url" | "text" | "email" | "tel" | undefined;
     };