@oracle/oraclejet-core-pack 17.1.3 → 18.0.0

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

@@ -1,4 +1,3 @@
-import { ValidationResult } from 'oj-c/editable-value/UNSAFE_useValidators/useValidators';
 import { ItemContext } from 'ojs/ojcommontypes';
 import { DataProvider } from 'ojs/ojdataprovider';
 import { Dispatch, StateUpdater } from 'preact/hooks';
@@ -8,13 +7,13 @@ type ValueItems<K, D> = Optional<Map<K, ItemContext<K, D>>>;
 export type UseSyncValueAndValueItemsProps<K, D> = {
     addBusyState: (desc?: string) => () => void;
     dataProvider?: Optional<DataProvider<K, D>>;
-    setDisplayValue: Dispatch<StateUpdater<Value<K>>>;
+    setDisplayValue: (value: Value<K>) => void;
     setIsLoading: Dispatch<StateUpdater<boolean>>;
-    setValue: Dispatch<StateUpdater<Value<K>>>;
+    setValue: (value: Value<K>) => void;
     setValueItems: (value: ValueItems<K, D>) => void;
     value?: Value<K>;
     valueItems?: ValueItems<K, D>;
-    validateValueOnExternalChange: (value: Value<K>) => ValidationResult;
+    validateValueOnExternalChange: (value: Value<K>) => boolean;
 };
 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

@@ -83,6 +83,7 @@ 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;
+    UNSAFE_focusAndOpenDropdown: () => void;
     _doAdvancedSearchAction: (searchText: string) => void;
     _selectItemByValue: (value: V | null) => Promise<void>;
     blur: () => void;

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

@@ -4,36 +4,36 @@ import type { SelectSingleProps } from './select-single';
 export declare function useSelectSinglePreact<V extends string | number, D extends Record<string, any>>({ advancedSearch, collectionTemplate, data, 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;
+        validate: () => Promise<"valid" | "invalid">;
     };
     selectSingleProps: {
         advancedSearch: "off" | "on" | undefined;
         'aria-describedby': string | undefined;
-        collectionRenderer: ((collectionRendererProps: import("@oracle/oraclejet-preact/UNSAFE_SelectSingle/SelectSingle.types").CollectionRendererProps<V, D>) => import("preact").ComponentChildren) | undefined;
-        data: import("@oracle/oraclejet-preact/UNSAFE_Collection").DataState<V, D> | null;
+        collectionRenderer: ((collectionRendererProps: import("@oracle/oraclejet-preact/dist/types/UNSAFE_SelectSingle/SelectSingle.types").CollectionRendererProps<V, D>) => import("preact").ComponentChildren) | undefined;
+        data: import("@oracle/oraclejet-preact/dist/types/UNSAFE_Collection").DataState<V, D> | null;
         isDisabled: boolean | undefined;
         isLoading: boolean;
         isReadonly: boolean | undefined;
         isRequired: boolean | undefined;
         isRequiredShown: boolean | undefined;
-        itemRenderer: ((itemRendererProps: import("@oracle/oraclejet-preact/UNSAFE_SelectSingle/SelectSingle.types").ItemRendererProps<V, D>) => import("preact").ComponentChildren) | undefined;
+        itemRenderer: ((itemRendererProps: import("@oracle/oraclejet-preact/dist/types/UNSAFE_SelectSingle/SelectSingle.types").ItemRendererProps<V, D>) => import("preact").ComponentChildren) | undefined;
         itemText: keyof D | ((itemContext: ItemContext<V, 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;
         onAdvancedSearchAction: ({ searchText }: {
-            searchText?: string | undefined;
+            searchText?: string;
         }) => void;
         onCommit: ({ previousValue, value }: ValueUpdateDetail<V>) => Promise<void>;
         onFilter: ({ searchText }: {
             searchText?: string;
         }) => void;
-        onLoadRange: (range: import("@oracle/oraclejet-preact/UNSAFE_Collection").Range) => void;
+        onLoadRange: (range: import("@oracle/oraclejet-preact/dist/types/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;
         valueItem: ItemContext<V, D> | undefined;
         virtualKeyboard: "number" | "search" | "auto" | "url" | "text" | "email" | "tel" | undefined;
     };

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

@@ -1,4 +1,3 @@
-import { ValidationResult } from 'oj-c/editable-value/UNSAFE_useValidators/useValidators';
 import { Optional } from 'oj-c/select-common/utils/utils';
 import { ItemContext } from 'ojs/ojcommontypes';
 import { DataProvider } from 'ojs/ojdataprovider';
@@ -8,13 +7,13 @@ type ValueItem<K, D> = Optional<ItemContext<K, D>>;
 export type UseSyncValueAndValueItemProps<K, D> = {
     addBusyState: (desc?: string) => () => void;
     dataProvider?: Optional<DataProvider<K, D>>;
-    setDisplayValue: Dispatch<StateUpdater<Value<K>>>;
+    setDisplayValue: (value: Value<K>) => void;
     setIsLoading: Dispatch<StateUpdater<boolean>>;
-    setValue: Dispatch<StateUpdater<Value<K>>>;
+    setValue: (value: Value<K>) => void;
     setValueItem: (value: ValueItem<K, D>) => void;
     value?: Value<K>;
     valueItem?: ValueItem<K, D>;
-    validateValueOnExternalChange: (value: Value<K>) => ValidationResult;
+    validateValueOnExternalChange: (value: Value<K>) => boolean;
 };
 export declare function useSyncValueAndValueItem<K extends string | number, D extends Record<string, any>>({ addBusyState, dataProvider, setDisplayValue, setIsLoading, setValue, setValueItem, value, valueItem, validateValueOnExternalChange }: UseSyncValueAndValueItemProps<K, D>): void;
 export {};

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

@@ -7,8 +7,8 @@ import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged } from 'ojs/ojv
 import { ImmutableKeySet } from 'ojs/ojkeyset';
 type PreactSelectorProps = ComponentProps<typeof PreactSelector>;
 type Props<K extends string | number> = ObservedGlobalProps<'aria-label'> & {
-    rowKey: K;
-    selectedKeys: ImmutableKeySet<K>;
+    rowKey?: K;
+    selectedKeys?: ImmutableKeySet<K>;
     onSelectedKeysChanged?: PropertyChanged<ImmutableKeySet<K>>;
     indeterminate?: PreactSelectorProps['isPartial'];
     selectionMode?: PreactSelectorProps['selectionMode'];
@@ -39,8 +39,8 @@ export interface CSelectorElementEventMap<K extends string | number> extends HTM
 }
 export interface CSelectorElementSettableProperties<K extends string | number> extends JetSettableProperties {
     indeterminate?: Props<K>['indeterminate'];
-    rowKey: Props<K>['rowKey'];
-    selectedKeys: Props<K>['selectedKeys'];
+    rowKey?: Props<K>['rowKey'];
+    selectedKeys?: Props<K>['selectedKeys'];
     selectionMode?: Props<K>['selectionMode'];
 }
 export interface CSelectorElementSettablePropertiesLenient<K extends string | number> extends Partial<CSelectorElementSettableProperties<K>> {

package/oj-c/types/skeleton/index.d.ts

@@ -0,0 +1,2 @@
+export { Skeleton } from './skeleton';
+export { CSkeletonElement } from './skeleton';

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

@@ -0,0 +1,53 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+import { ExtendGlobalProps } from 'ojs/ojvcomponent';
+import { ComponentProps, ComponentType } from 'preact';
+type Props = {
+    height: Size;
+    width?: Size;
+    borderRadius?: Size;
+};
+declare const SkeletonImpl: ({ height, width, borderRadius }: Props) => import("preact").JSX.Element;
+export declare const Skeleton: ComponentType<ExtendGlobalProps<ComponentProps<typeof SkeletonImpl>>>;
+export {};
+export interface CSkeletonElement extends JetElement<CSkeletonElementSettableProperties>, CSkeletonElementSettableProperties {
+    addEventListener<T extends keyof CSkeletonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CSkeletonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CSkeletonElementSettableProperties>(property: T): CSkeletonElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CSkeletonElementSettableProperties>(property: T, value: CSkeletonElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CSkeletonElementSettableProperties>): void;
+    setProperties(properties: CSkeletonElementSettablePropertiesLenient): void;
+}
+export namespace CSkeletonElement {
+    type borderRadiusChanged = JetElementCustomEventStrict<CSkeletonElement['borderRadius']>;
+    type heightChanged = JetElementCustomEventStrict<CSkeletonElement['height']>;
+    type widthChanged = JetElementCustomEventStrict<CSkeletonElement['width']>;
+}
+export interface CSkeletonElementEventMap extends HTMLElementEventMap {
+    'borderRadiusChanged': JetElementCustomEventStrict<CSkeletonElement['borderRadius']>;
+    'heightChanged': JetElementCustomEventStrict<CSkeletonElement['height']>;
+    'widthChanged': JetElementCustomEventStrict<CSkeletonElement['width']>;
+}
+export interface CSkeletonElementSettableProperties extends JetSettableProperties {
+    borderRadius?: Props['borderRadius'];
+    height: Props['height'];
+    width?: Props['width'];
+}
+export interface CSkeletonElementSettablePropertiesLenient extends Partial<CSkeletonElementSettableProperties> {
+    [key: string]: any;
+}
+export interface SkeletonIntrinsicProps extends Partial<Readonly<CSkeletonElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onborderRadiusChanged?: (value: CSkeletonElementEventMap['borderRadiusChanged']) => void;
+    onheightChanged?: (value: CSkeletonElementEventMap['heightChanged']) => void;
+    onwidthChanged?: (value: CSkeletonElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-skeleton': SkeletonIntrinsicProps;
+        }
+    }
+}

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

@@ -8,7 +8,7 @@ import { MenuItemSelectionDetail, MenuItem, MenuSeparator } from '../utils/PRIVA
 export type { MenuValueUpdateDetail } from '@oracle/oraclejet-preact/UNSAFE_Menu/menuUtils';
 export type { MenuSelection, MenuItemSelectionDetail } from '../utils/PRIVATE_ItemsMenu/items-menu';
 export type MenuItems = MenuItem | MenuSeparator;
-import { ComponentProps, Component } from 'preact';
+import { ComponentProps, Ref, ComponentType } from 'preact';
 import 'css!oj-c/split-menu-button/split-menu-button-styles.css';
 type PreactSplitMenuButtonProps = ComponentProps<typeof PreactSplitMenuButton>;
 type Props = ObservedGlobalProps<'aria-describedby'> & {
@@ -22,14 +22,13 @@ type Props = ObservedGlobalProps<'aria-describedby'> & {
     chroming?: PreactSplitMenuButtonProps['variant'];
     onOjAction?: Action & Bubbles;
 };
-export declare class SplitMenuButton extends Component<ExtendGlobalProps<Props>> {
-    static defaultProps: Partial<Props>;
-    private buttonRef;
-    render({ chroming, label, disabled, size, width, items, tooltip, onOjMenuAction, 'aria-describedby': ariaDescribedBy, onOjAction: onAction }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
-    blur(): void;
-    focus(): void;
-    doAction(): void;
-}
+type SplitMenuButtonHandle = {
+    focus: () => void;
+    blur: () => void;
+    click: () => void;
+};
+declare function SplitMenuButtonImpl({ label, chroming, disabled, size, items, width, tooltip, onOjMenuAction, onOjAction, 'aria-describedby': ariaDescribedBy, ...otherProps }: Props, ref: Ref<SplitMenuButtonHandle>): import("preact").JSX.Element;
+export declare const SplitMenuButton: ComponentType<ExtendGlobalProps<ComponentProps<typeof SplitMenuButtonImpl>>>;
 export interface CSplitMenuButtonElement extends JetElement<CSplitMenuButtonElementSettableProperties>, CSplitMenuButtonElementSettableProperties {
     addEventListener<T extends keyof CSplitMenuButtonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CSplitMenuButtonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
@@ -38,9 +37,9 @@ export interface CSplitMenuButtonElement extends JetElement<CSplitMenuButtonElem
     setProperty<T extends keyof CSplitMenuButtonElementSettableProperties>(property: T, value: CSplitMenuButtonElementSettableProperties[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CSplitMenuButtonElementSettableProperties>): void;
     setProperties(properties: CSplitMenuButtonElementSettablePropertiesLenient): void;
-    blur: SplitMenuButton['blur'];
-    doAction: SplitMenuButton['doAction'];
-    focus: SplitMenuButton['focus'];
+    blur: () => void;
+    click: () => void;
+    focus: () => void;
 }
 export namespace CSplitMenuButtonElement {
     interface ojMenuAction extends CustomEvent<MenuItemSelectionDetail & {}> {

package/oj-c/types/tab-bar/ContentRenderer.d.ts

@@ -1,5 +1,4 @@
 import type { DataTabBarProps } from './DataTabBar.types';
-import { FocusableHandle } from '@oracle/oraclejet-preact/UNSAFE_TabBarMixed';
 import { RefObject } from 'preact';
-export declare function TabBarRenderer<K extends string | number>(props: Omit<DataTabBarProps<K>, 'overflow' | 'onSelect'>, handleSelect: DataTabBarProps<K>['onSelect'], ref?: RefObject<FocusableHandle>): import("preact").JSX.Element;
+export declare function TabBarRenderer<K extends string | number>(props: Omit<DataTabBarProps<K>, 'overflow' | 'onSelect'>, handleSelect: DataTabBarProps<K>['onSelect'], rootRef: RefObject<HTMLDivElement>): import("preact").JSX.Element;
 export declare function OverflowTabBarRenderer<K extends string | number>(props: Omit<DataTabBarProps<K>, 'reorderable' | 'onReorder' | 'onSelect' | 'overflow'>, handleSelect: DataTabBarProps<K>['onSelect']): import("preact").JSX.Element;

package/oj-c/types/tab-bar/DataTabBar.types.d.ts

@@ -15,8 +15,18 @@ export type TabData<K extends string | number> = {
     tabPanelId?: string;
     isRemovable?: boolean;
 };
+export type TabLinkItemData<K extends string | number> = {
+    itemKey: K;
+    label: string;
+    icon?: TabIconData;
+    badge?: number;
+    metadata?: string;
+    severity?: Severity;
+    tabPanelId?: string;
+    href: string;
+};
 export type DataTabBarProps<K extends string | number> = {
-    data: TabData<K>[];
+    data: (TabData<K> | TabLinkItemData<K>)[];
     onRemove: TabBarProps['onRemove'];
     onSelect: TabBarProps['onSelect'];
     selection: TabBarProps['selection'];
@@ -26,6 +36,7 @@ export type DataTabBarProps<K extends string | number> = {
     overflow?: 'conveyor' | 'popup' | 'hidden';
     onReorder?: ReorderableTabBarProps['onReorder'];
     reorderable?: 'enabled' | 'disabled';
+    truncation?: 'none' | 'progressive';
     'aria-label'?: TabBarProps['aria-label'];
     'aria-labelledby'?: TabBarProps['aria-labelledby'];
 };

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

@@ -5,7 +5,7 @@ import type { Action, CancelableAction, ExtendGlobalProps, ObservedGlobalProps,
 import type { ComponentProps, ComponentType } from 'preact';
 import { DataProvider } from 'ojs/ojdataprovider';
 import { DataTabBar } from './DataTabBar';
-type DataTabBarProps = ComponentProps<typeof DataTabBar>;
+export type DataTabBarProps = ComponentProps<typeof DataTabBar>;
 type Severity = 'warning' | 'info' | 'none' | 'error' | 'confirmation';
 export type TabIconData = {
     type?: 'class';
@@ -24,6 +24,16 @@ export type TabData<K extends string | number> = {
     tabPanelId?: string;
     isRemovable?: boolean;
 };
+export type TabLinkItemData<K extends string | number> = {
+    itemKey: K;
+    label: string;
+    icon?: TabIconData;
+    badge?: number;
+    metadata?: string;
+    severity?: Severity;
+    tabPanelId?: string;
+    href: string;
+};
 export type KeyDetail<K extends string | number> = {
     key: K;
 };
@@ -35,7 +45,7 @@ export type ReorderDetail<K extends string | number> = {
     reorderedKeys: K[];
 };
 export type Props<K extends string | number> = ObservedGlobalProps<'aria-label' | 'id' | 'aria-labelledby'> & {
-    data?: DataTabBarProps['data'] | DataProvider<K, TabData<K>>;
+    data?: DataTabBarProps['data'] | DataProvider<K, TabData<K> | TabLinkItemData<K>>;
     selection?: K;
     onOjBeforeSelect?: CancelableAction<KeyDetail<K>>;
     onOjRemove?: Action<KeyDetail<K>>;
@@ -47,6 +57,7 @@ export type Props<K extends string | number> = ObservedGlobalProps<'aria-label'
     display?: DataTabBarProps['display'];
     layout?: DataTabBarProps['layout'];
     edge?: DataTabBarProps['edge'];
+    truncation?: DataTabBarProps['truncation'];
 };
 export declare const TabBar: ComponentType<ExtendGlobalProps<Props<string | number>>>;
 export {};
@@ -78,6 +89,7 @@ export namespace CTabBarElement {
     type overflowChanged = JetElementCustomEventStrict<CTabBarElement['overflow']>;
     type reorderableChanged = JetElementCustomEventStrict<CTabBarElement['reorderable']>;
     type selectionChanged = JetElementCustomEventStrict<CTabBarElement['selection']>;
+    type truncationChanged = JetElementCustomEventStrict<CTabBarElement['truncation']>;
 }
 export interface CTabBarElementEventMap extends HTMLElementEventMap {
     'ojBeforeSelect': CTabBarElement.ojBeforeSelect<string | number>;
@@ -91,6 +103,7 @@ export interface CTabBarElementEventMap extends HTMLElementEventMap {
     'overflowChanged': JetElementCustomEventStrict<CTabBarElement['overflow']>;
     'reorderableChanged': JetElementCustomEventStrict<CTabBarElement['reorderable']>;
     'selectionChanged': JetElementCustomEventStrict<CTabBarElement['selection']>;
+    'truncationChanged': JetElementCustomEventStrict<CTabBarElement['truncation']>;
 }
 export interface CTabBarElementSettableProperties<K extends string | number> extends JetSettableProperties {
     data?: Props<K>['data'];
@@ -100,6 +113,7 @@ export interface CTabBarElementSettableProperties<K extends string | number> ext
     overflow?: Props<K>['overflow'];
     reorderable?: Props<K>['reorderable'];
     selection?: Props<K>['selection'];
+    truncation?: Props<K>['truncation'];
 }
 export interface CTabBarElementSettablePropertiesLenient<K extends string | number> extends Partial<CTabBarElementSettableProperties<K>> {
     [key: string]: any;
@@ -116,6 +130,7 @@ export interface TabBarIntrinsicProps extends Partial<Readonly<CTabBarElementSet
     onoverflowChanged?: (value: CTabBarElementEventMap['overflowChanged']) => void;
     onreorderableChanged?: (value: CTabBarElementEventMap['reorderableChanged']) => void;
     onselectionChanged?: (value: CTabBarElementEventMap['selectionChanged']) => void;
+    ontruncationChanged?: (value: CTabBarElementEventMap['truncationChanged']) => void;
 }
 declare global {
     namespace preact.JSX {

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

@@ -50,6 +50,11 @@ export type Column<K, D> = {
     padding?: 'enabled' | 'disabled' | CellPadding | ((context: RowContext<K, D>) => 'enabled' | 'disabled' | CellPadding);
     headerPadding?: 'enabled' | 'disabled' | CellPadding;
     footerPadding?: 'enabled' | 'disabled' | CellPadding;
+    tooltip?: 'enabled' | 'disabled' | ((context: RowContext<K, D>) => 'enabled' | 'disabled');
+    headerTooltip?: 'enabled' | 'disabled';
+    footerTooltip?: 'enabled' | 'disabled';
+    sticky?: 'enabled' | 'disabled';
+    horizontalAlignment?: 'start' | 'end' | 'left' | 'right' | 'center';
 };
 declare const _SELECTION_COLUMN_KEY = "oj-c-table_selection";
 type TableDefaultColumnKey = typeof _SELECTION_COLUMN_KEY;

package/oj-c/types/tag-cloud/index.d.ts

@@ -1,2 +1,2 @@
-export { TagCloud } from './tag-cloud';
+export { TagCloud, TagCloudContextMenuActionDetail, TagCloudContextMenuSelectionDetail } from './tag-cloud';
 export { CTagCloudElement } from './tag-cloud';

package/oj-c/types/tag-cloud/tag-cloud.d.ts

@@ -6,8 +6,19 @@ import { TagCloud as PreactTagCloud } from '@oracle/oraclejet-preact/UNSAFE_TagC
 import 'css!oj-c/tag-cloud/tag-cloud-styles.css';
 import { DataProvider } from 'ojs/ojdataprovider';
 import { TagCloudItemProps } from '../tag-cloud-item/tag-cloud-item';
-import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
+import { Action, Bubbles, ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, TemplateSlot } from 'ojs/ojvcomponent';
+import { type ContextMenuConfig, type ContextMenuSelectionDetail, type ContextMenuActionDetail } from 'oj-c/hooks/PRIVATE_useVisContextMenu/useVisContextMenu';
 type PreactTagCloudProps = ComponentProps<typeof PreactTagCloud>;
+export type TagCloudContextMenuConfig<K, D> = ContextMenuConfig<TagcloudContextMenuContext<K, D>>;
+export type TagCloudContextMenuSelectionDetail<K, D> = ContextMenuSelectionDetail<TagcloudContextMenuContext<K, D>>;
+export type TagCloudContextMenuActionDetail<K, D> = ContextMenuActionDetail<TagcloudContextMenuContext<K, D>>;
+export type TagcloudContextMenuContext<K, D> = {
+    data?: Item<K>;
+    itemData?: D;
+    type: 'item';
+} | {
+    type: 'background';
+};
 type DatatipContext<K> = {
     id: K;
 };
@@ -34,8 +45,11 @@ export type TagCloudProps<K, D extends Item<K> | any> = ObservedGlobalProps<'ari
     selection?: K[];
     onSelectionChanged?: PropertyChanged<K[]>;
     itemTemplate?: TemplateSlot<TagCloudItemTemplateContext<K, D>>;
+    contextMenuConfig?: TagCloudContextMenuConfig<K, D>;
+    onOjContextMenuAction?: Action<TagCloudContextMenuActionDetail<K, D>> & Bubbles;
+    onOjContextMenuSelection?: Action<TagCloudContextMenuSelectionDetail<K, D>> & Bubbles;
 };
-declare function TagCloudComp<K extends string | number, D extends any>({ hiddenCategories, data, highlightedCategories, hoverBehavior, layout, selection, selectionMode, highlightMatch, ...props }: TagCloudProps<K, D>): import("preact").JSX.Element;
+declare function TagCloudComp<K extends string | number, D extends any>({ hiddenCategories, data, highlightedCategories, hoverBehavior, layout, selection, selectionMode, highlightMatch, contextMenuConfig, onOjContextMenuAction, onOjContextMenuSelection, ...props }: TagCloudProps<K, D>): import("preact").JSX.Element;
 export declare const TagCloud: ComponentType<ExtendGlobalProps<ComponentProps<typeof TagCloudComp>>>;
 export {};
 export interface CTagCloudElement<K extends string | number, D extends any> extends JetElement<CTagCloudElementSettableProperties<K, D>>, CTagCloudElementSettableProperties<K, D> {
@@ -48,6 +62,11 @@ export interface CTagCloudElement<K extends string | number, D extends any> exte
     setProperties(properties: CTagCloudElementSettablePropertiesLenient<K, D>): void;
 }
 export namespace CTagCloudElement {
+    interface ojContextMenuAction<K extends string | number, D extends any> extends CustomEvent<TagCloudContextMenuActionDetail<K, D> & {}> {
+    }
+    interface ojContextMenuSelection<K extends string | number, D extends any> extends CustomEvent<TagCloudContextMenuSelectionDetail<K, D> & {}> {
+    }
+    type contextMenuConfigChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['contextMenuConfig']>;
     type dataChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['data']>;
     type datatipChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['datatip']>;
     type hiddenCategoriesChanged<K extends string | number, D extends any> = JetElementCustomEventStrict<CTagCloudElement<K, D>['hiddenCategories']>;
@@ -61,6 +80,9 @@ export namespace CTagCloudElement {
     type RenderItemTemplate<K extends string | number, D extends any> = import('ojs/ojvcomponent').TemplateSlot<TagCloudItemTemplateContext<K, D>>;
 }
 export interface CTagCloudElementEventMap<K extends string | number, D extends any> extends HTMLElementEventMap {
+    'ojContextMenuAction': CTagCloudElement.ojContextMenuAction<K, D>;
+    'ojContextMenuSelection': CTagCloudElement.ojContextMenuSelection<K, D>;
+    'contextMenuConfigChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['contextMenuConfig']>;
     'dataChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['data']>;
     'datatipChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['datatip']>;
     'hiddenCategoriesChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['hiddenCategories']>;
@@ -73,6 +95,7 @@ export interface CTagCloudElementEventMap<K extends string | number, D extends a
     'touchResponseChanged': JetElementCustomEventStrict<CTagCloudElement<K, D>['touchResponse']>;
 }
 export interface CTagCloudElementSettableProperties<K, D extends Item<K> | any> extends JetSettableProperties {
+    contextMenuConfig?: TagCloudProps<K, D>['contextMenuConfig'];
     data: TagCloudProps<K, D>['data'];
     datatip?: TagCloudProps<K, D>['datatip'];
     hiddenCategories?: TagCloudProps<K, D>['hiddenCategories'];
@@ -89,6 +112,9 @@ export interface CTagCloudElementSettablePropertiesLenient<K, D extends Item<K>
 }
 export interface TagCloudIntrinsicProps extends Partial<Readonly<CTagCloudElementSettableProperties<any, any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
     children?: import('preact').ComponentChildren;
+    onojContextMenuAction?: (value: CTagCloudElementEventMap<any, any>['ojContextMenuAction']) => void;
+    onojContextMenuSelection?: (value: CTagCloudElementEventMap<any, any>['ojContextMenuSelection']) => void;
+    oncontextMenuConfigChanged?: (value: CTagCloudElementEventMap<any, any>['contextMenuConfigChanged']) => void;
     ondataChanged?: (value: CTagCloudElementEventMap<any, any>['dataChanged']) => void;
     ondatatipChanged?: (value: CTagCloudElementEventMap<any, any>['datatipChanged']) => void;
     onhiddenCategoriesChanged?: (value: CTagCloudElementEventMap<any, any>['hiddenCategoriesChanged']) => void;

package/oj-c/types/tag-cloud/utils.d.ts

@@ -1,9 +1,10 @@
+import { HTMLAttributesSignalExcluded } from '@oracle/oraclejet-preact/utils/UNSAFE_attributeUtils';
 export declare function transformItem(dataItem: any): {
     color: any;
     accessibleLabel: any;
     value: any;
     label: any;
     id: any;
-    role: import("preact").JSX.AriaRole | undefined;
+    role: HTMLAttributesSignalExcluded["role"];
 };
 export declare function executeLink(dest: string): void;

package/oj-c/types/text-area/useTextAreaAutosizePreact.d.ts

@@ -1,43 +1,14 @@
 import { ComponentProps } from 'preact';
+import type { TextAreaAutosize } from '@oracle/oraclejet-preact/UNSAFE_TextAreaAutosize';
 import type { TextArea } from 'oj-c/text-area';
+type PreactTextAreaAutosizeProps = ComponentProps<typeof TextAreaAutosize>;
 type TextAreaProps = ComponentProps<typeof TextArea>;
 export declare function useTextAreaAutosizePreact<V>({ autocomplete, autofocus, converter, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, maxRows, messagesCustom, placeholder, readonly, required, requiredMessageDetail, resizeBehavior, rows, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValidChanged, onValueChanged, ...otherProps }: TextAreaProps, addBusyState?: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         showMessages: () => void;
-        validate: () => Promise<"invalid" | "valid">;
-    };
-    textAreaProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
-        'aria-describedby'?: string | undefined;
-        assistiveText?: string | undefined;
-        autoComplete?: string | undefined;
-        autoFocus?: boolean | undefined;
-        columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
-        helpSourceLink?: string | undefined;
-        helpSourceText?: string | undefined;
-        isDisabled?: boolean | undefined;
-        isReadonly?: boolean | undefined;
-        isRequired?: boolean | undefined;
-        isRequiredShown?: boolean | undefined;
-        label: string;
-        labelEdge?: "none" | "start" | "top" | "inside" | undefined;
-        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
-        maxLength?: number | undefined;
-        maxLengthCounter?: "none" | "remaining" | undefined;
-        maxLengthUnit?: import("@oracle/oraclejet-preact/utils/UNSAFE_lengthFilter").CountUnit | undefined;
-        maxRows?: number | undefined;
-        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
-        minRows?: number | undefined;
-        placeholder?: string | undefined;
-        role?: import("preact").JSX.AriaRole | undefined;
-        textAlign?: "end" | "start" | "right" | undefined;
-        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
-        value?: string | undefined;
-        variant?: "default" | "embedded" | undefined;
-        onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-        onInput: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-    }> & {
-        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle & Partial<import("@oracle/oraclejet-preact/hooks/UNSAFE_useSelectableTextField").SelectableHandle>> | undefined;
+        validate: () => Promise<"valid" | "invalid">;
     };
+    textAreaProps: PreactTextAreaAutosizeProps;
 };
 export {};

package/oj-c/types/text-area/useTextAreaPreact.d.ts

@@ -1,43 +1,14 @@
 import { ComponentProps } from 'preact';
+import type { TextArea as PreactTextArea } from '@oracle/oraclejet-preact/UNSAFE_TextArea';
 import type { TextArea } from 'oj-c/text-area';
+type PreactTextAreaProps = ComponentProps<typeof PreactTextArea>;
 type TextAreaProps = ComponentProps<typeof TextArea>;
 export declare function useTextAreaPreact<V>({ autocomplete, autofocus, converter, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, messagesCustom, placeholder, readonly, required, requiredMessageDetail, resizeBehavior, rows, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValueChanged, onValidChanged, ...otherProps }: TextAreaProps, addBusyState?: (desc?: string) => () => void): {
     methods: {
         reset: () => void;
         showMessages: () => void;
-        validate: () => Promise<"invalid" | "valid">;
-    };
-    textAreaProps: import("preact/compat").PropsWithoutRef<import("@oracle/oraclejet-preact/hooks/UNSAFE_useTestId").TestIdProps & {
-        'aria-describedby'?: string | undefined;
-        assistiveText?: string | undefined;
-        autoComplete?: string | undefined;
-        autoFocus?: boolean | undefined;
-        columnSpan?: import("@oracle/oraclejet-preact/utils/UNSAFE_styles/Layout").LayoutColumns | undefined;
-        helpSourceLink?: string | undefined;
-        helpSourceText?: string | undefined;
-        isDisabled?: boolean | undefined;
-        isReadonly?: boolean | undefined;
-        isRequired?: boolean | undefined;
-        isRequiredShown?: boolean | undefined;
-        label: string;
-        labelEdge?: "none" | "start" | "top" | "inside" | undefined;
-        labelStartWidth?: import("@oracle/oraclejet-preact/utils/UNSAFE_size").Size | undefined;
-        maxLength?: number | undefined;
-        maxLengthCounter?: "none" | "remaining" | undefined;
-        maxLengthUnit?: import("@oracle/oraclejet-preact/utils/UNSAFE_lengthFilter").CountUnit | undefined;
-        messages?: import("@oracle/oraclejet-preact/UNSAFE_ComponentMessage").ComponentMessageItem[] | undefined;
-        placeholder?: string | undefined;
-        resize?: "both" | "horizontal" | "vertical" | undefined;
-        role?: import("preact").JSX.AriaRole | undefined;
-        rows?: number | undefined;
-        textAlign?: "end" | "start" | "right" | undefined;
-        userAssistanceDensity?: import("@oracle/oraclejet-preact/UNSAFE_UserAssistance").UserAssistanceDensityType | undefined;
-        value?: string | undefined;
-        variant?: "default" | "embedded" | undefined;
-        onCommit?: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-        onInput: ((detail: import("@oracle/oraclejet-preact/utils/UNSAFE_valueUpdateDetail").ValueUpdateDetail<string>) => void) | undefined;
-    }> & {
-        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle & Partial<import("@oracle/oraclejet-preact/hooks/UNSAFE_useSelectableTextField").SelectableHandle>> | undefined;
+        validate: () => Promise<"valid" | "invalid">;
     };
+    textAreaProps: PreactTextAreaProps;
 };
 export {};

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

@@ -4,7 +4,7 @@ import 'ojs/oj-jsx-interfaces';
 import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, Slot } from 'ojs/ojvcomponent';
 import { ToggleButton as PreactToggleButton } from '@oracle/oraclejet-preact/UNSAFE_ToggleButton';
 import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
-import { ComponentProps, Component } from 'preact';
+import { ComponentProps, Ref, ComponentType } from 'preact';
 import 'css!oj-c/button/button-styles.css';
 type PreactToggleButtonProps = ComponentProps<typeof PreactToggleButton>;
 type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
@@ -20,14 +20,13 @@ type Props = ObservedGlobalProps<'aria-describedby' | 'aria-label'> & {
     size?: 'sm' | 'md' | 'lg';
     chroming?: PreactToggleButtonProps['variant'];
 };
-export declare class ToggleButton extends Component<ExtendGlobalProps<Props>> {
-    static defaultProps: Partial<Props>;
-    private buttonRef;
-    render({ chroming: variant, disabled: isDisabled, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy, width, display, value, label, tooltip, endIcon, startIcon, size, onValueChanged }: ExtendGlobalProps<Props>): import("preact").JSX.Element;
-    click(): void;
-    blur(): void;
-    focus(): void;
-}
+type ToggleButtonHandle = {
+    focus: () => void;
+    blur: () => void;
+    click: () => void;
+};
+declare function ToggleButtonImpl({ chroming, disabled, 'aria-label': accessibleLabel, 'aria-describedby': ariaDescribedBy, width, display, value, label, tooltip, startIcon, endIcon, size, onValueChanged }: Props, ref: Ref<ToggleButtonHandle>): import("preact").JSX.Element;
+export declare const ToggleButton: ComponentType<ExtendGlobalProps<ComponentProps<typeof ToggleButtonImpl>>>;
 export {};
 export interface CToggleButtonElement extends JetElement<CToggleButtonElementSettableProperties>, CToggleButtonElementSettableProperties {
     addEventListener<T extends keyof CToggleButtonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CToggleButtonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
@@ -37,9 +36,9 @@ export interface CToggleButtonElement extends JetElement<CToggleButtonElementSet
     setProperty<T extends keyof CToggleButtonElementSettableProperties>(property: T, value: CToggleButtonElementSettableProperties[T]): void;
     setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CToggleButtonElementSettableProperties>): void;
     setProperties(properties: CToggleButtonElementSettablePropertiesLenient): void;
-    blur: ToggleButton['blur'];
-    click: ToggleButton['click'];
-    focus: ToggleButton['focus'];
+    blur: () => void;
+    click: () => void;
+    focus: () => void;
 }
 export namespace CToggleButtonElement {
     type chromingChanged = JetElementCustomEventStrict<CToggleButtonElement['chroming']>;

package/oj-c/types/toolbar/index.d.ts

@@ -0,0 +1,2 @@
+export { Toolbar, ToolbarSelection } from './toolbar';
+export { CToolbarElement } from './toolbar';

package/oj-c/types/toolbar/items-toolbar.d.ts

@@ -0,0 +1,15 @@
+import { PropertyChanged } from 'ojs/ojvcomponent';
+import { SelectToolbarItemDetail, ToolbarItems, ToolbarActionDetail, ToolbarSelection, ItemChroming, ItemSizes } from './itemsTypes';
+export type { ToolbarItems, ToolbarActionDetail, ToolbarSelection, ToolbarSelectionDetail, ItemChroming, ItemSizes } from './itemsTypes';
+type Props = {
+    items?: ToolbarItems[];
+    chroming?: ItemChroming;
+    size?: ItemSizes;
+    toolbarSelection?: Record<string, ToolbarSelection>;
+    onToolbarSelectionChanged?: PropertyChanged<Record<string, ToolbarSelection>>;
+    onOjToolbarAction?: (details: ToolbarActionDetail) => void;
+    onOjToolbarSelection?: (details: SelectToolbarItemDetail<ToolbarSelection> & {
+        toolbarSelectionGroupKey: string;
+    }) => void;
+};
+export declare const ItemsToolbar: ({ items, size, chroming, toolbarSelection, onToolbarSelectionChanged, onOjToolbarAction, onOjToolbarSelection }: Props) => import("preact").JSX.Element;