@oracle/oraclejet-core-pack 14.0.0

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

@@ -0,0 +1,93 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { SplitMenuButton as PreactSplitMenuButton } from '@oracle/oraclejet-preact/UNSAFE_SplitMenuButton';
+import { ComponentProps, Component } from 'preact';
+import { ExtendGlobalProps, Action, Bubbles, ObservedGlobalProps } from 'ojs/ojvcomponent';
+import 'css!oj-c/split-menu-button/split-menu-button-styles.css';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+declare type PreactSplitMenuButtonProps = ComponentProps<typeof PreactSplitMenuButton>;
+export declare type SplitMenuButtonMenuItemType = 'item' | 'divider';
+export declare type SplitMenuButtonMenuItem = {
+    type?: SplitMenuButtonMenuItemType;
+    label?: string;
+    disabled?: boolean;
+    onAction?: () => void;
+};
+declare type Props = ObservedGlobalProps<'title'> & {
+    label: string;
+    items?: Array<SplitMenuButtonMenuItem>;
+    disabled?: boolean;
+    size?: PreactSplitMenuButtonProps['size'];
+    width?: Size;
+    chroming?: PreactSplitMenuButtonProps['variant'];
+    onOjAction?: Action & Bubbles;
+};
+export declare class SplitMenuButton extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private buttonRef;
+    private renderMenu;
+    render(props: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    blur(): void;
+    focus(): void;
+    doAction(): void;
+}
+export {};
+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;
+    getProperty<T extends keyof CSplitMenuButtonElementSettableProperties>(property: T): CSplitMenuButtonElement[T];
+    getProperty(property: string): any;
+    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'];
+}
+export namespace CSplitMenuButtonElement {
+    interface ojAction extends CustomEvent<{}> {
+    }
+    type chromingChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['chroming']>;
+    type disabledChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['disabled']>;
+    type itemsChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['items']>;
+    type labelChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['label']>;
+    type sizeChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['size']>;
+    type widthChanged = JetElementCustomEventStrict<CSplitMenuButtonElement['width']>;
+}
+export interface CSplitMenuButtonElementEventMap extends HTMLElementEventMap {
+    'ojAction': CSplitMenuButtonElement.ojAction;
+    'chromingChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['chroming']>;
+    'disabledChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['disabled']>;
+    'itemsChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['items']>;
+    'labelChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['label']>;
+    'sizeChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['size']>;
+    'widthChanged': JetElementCustomEventStrict<CSplitMenuButtonElement['width']>;
+}
+export interface CSplitMenuButtonElementSettableProperties extends JetSettableProperties {
+    chroming?: Props['chroming'];
+    disabled?: Props['disabled'];
+    items?: Props['items'];
+    label: Props['label'];
+    size?: Props['size'];
+    width?: Props['width'];
+}
+export interface CSplitMenuButtonElementSettablePropertiesLenient extends Partial<CSplitMenuButtonElementSettableProperties> {
+    [key: string]: any;
+}
+export interface SplitMenuButtonIntrinsicProps extends Partial<Readonly<CSplitMenuButtonElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onojAction?: (value: CSplitMenuButtonElementEventMap['ojAction']) => void;
+    onchromingChanged?: (value: CSplitMenuButtonElementEventMap['chromingChanged']) => void;
+    ondisabledChanged?: (value: CSplitMenuButtonElementEventMap['disabledChanged']) => void;
+    onitemsChanged?: (value: CSplitMenuButtonElementEventMap['itemsChanged']) => void;
+    onlabelChanged?: (value: CSplitMenuButtonElementEventMap['labelChanged']) => void;
+    onsizeChanged?: (value: CSplitMenuButtonElementEventMap['sizeChanged']) => void;
+    onwidthChanged?: (value: CSplitMenuButtonElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-split-menu-button': SplitMenuButtonIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { TextArea } from './text-area';
+export { CTextAreaElement } from './text-area';

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

@@ -0,0 +1,209 @@
+/// <reference types="ojconverter" />
+/// <reference types="ojvalidator-async" />
+/// <reference types="ojvalidator" />
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { TextArea as PreactTextArea } from '@oracle/oraclejet-preact/UNSAFE_TextArea';
+import { Help, HelpHints } from 'oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText';
+import Converter from 'ojs/ojconverter';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+import { ExtendGlobalProps, ObservedGlobalProps, PropertyChanged, ReadOnlyPropertyChanged } from 'ojs/ojvcomponent';
+import { Component, ComponentProps } from 'preact';
+import 'css!oj-c/text-area/text-area-styles.css';
+declare type PreactTextAreaProps = ComponentProps<typeof PreactTextArea>;
+declare type DisplayOptions = {
+    converterHint?: 'display' | 'none';
+    messages?: 'display' | 'none';
+    validatorHint?: 'display' | 'none';
+};
+declare type Length = {
+    countBy?: 'codePoint' | 'codeUnit';
+    counter?: 'none' | 'remaining';
+    max?: number | null;
+};
+declare type ValidState = 'valid' | 'pending' | 'invalidHidden' | 'invalidShown';
+declare type Props<V> = ObservedGlobalProps<'aria-describedby' | 'autofocus' | 'id'> & {
+    autocomplete?: 'on' | 'off' | string;
+    containerReadonly?: boolean;
+    converter?: Converter<V> | null;
+    disabled?: boolean;
+    displayOptions?: DisplayOptions;
+    help?: Help;
+    helpHints?: HelpHints;
+    labelEdge?: PreactTextAreaProps['labelEdge'];
+    labelHint: string;
+    labelStartWidth?: string;
+    labelWrapping?: 'truncate' | 'wrap';
+    length?: Length;
+    maxRows?: number;
+    messagesCustom?: PreactTextAreaProps['messages'];
+    placeholder?: string;
+    readonly?: boolean;
+    required?: boolean;
+    requiredMessageDetail?: string;
+    resizeBehavior?: PreactTextAreaProps['resize'] | 'none';
+    rows?: number;
+    textAlign?: PreactTextAreaProps['textAlign'];
+    userAssistanceDensity?: PreactTextAreaProps['userAssistanceDensity'];
+    validators?: (AsyncValidator<V> | Validator<V>)[] | null;
+    value?: V | null;
+    onMessagesCustomChanged?: PropertyChanged<PreactTextAreaProps['messages']>;
+    onRawValueChanged?: ReadOnlyPropertyChanged<string>;
+    onValidChanged?: ReadOnlyPropertyChanged<ValidState>;
+    onValueChanged?: PropertyChanged<V>;
+};
+export declare class TextArea<V> extends Component<ExtendGlobalProps<Props<V>>> {
+    static defaultProps: Partial<Props<any>>;
+    private busyContextRef;
+    private textAreaRef;
+    private rootRef;
+    componentDidMount(): void;
+    render(props: ExtendGlobalProps<Props<V>>): import("preact").JSX.Element;
+    componentWillUnmount(): void;
+    reset(): void;
+    showMessages(): void;
+    validate(): Promise<'valid' | 'invalid'>;
+    blur(): void;
+    focus(): void;
+}
+export {};
+export interface CTextAreaElement<V> extends JetElement<CTextAreaElementSettableProperties<V>>, CTextAreaElementSettableProperties<V> {
+    readonly rawValue?: Parameters<Required<Props<V>>['onRawValueChanged']>[0];
+    readonly valid?: Parameters<Required<Props<V>>['onValidChanged']>[0];
+    addEventListener<T extends keyof CTextAreaElementEventMap<V>>(type: T, listener: (this: HTMLElement, ev: CTextAreaElementEventMap<V>[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CTextAreaElementSettableProperties<V>>(property: T): CTextAreaElement<V>[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CTextAreaElementSettableProperties<V>>(property: T, value: CTextAreaElementSettableProperties<V>[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CTextAreaElementSettableProperties<V>>): void;
+    setProperties(properties: CTextAreaElementSettablePropertiesLenient<V>): void;
+    blur: TextArea<V>['blur'];
+    focus: TextArea<V>['focus'];
+    reset: TextArea<V>['reset'];
+    showMessages: TextArea<V>['showMessages'];
+    validate: TextArea<V>['validate'];
+}
+export namespace CTextAreaElement {
+    type autocompleteChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['autocomplete']>;
+    type containerReadonlyChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['containerReadonly']>;
+    type converterChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['converter']>;
+    type disabledChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['disabled']>;
+    type displayOptionsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['displayOptions']>;
+    type helpChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['help']>;
+    type helpHintsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['helpHints']>;
+    type labelEdgeChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['labelEdge']>;
+    type labelHintChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['labelHint']>;
+    type labelStartWidthChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['labelStartWidth']>;
+    type labelWrappingChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['labelWrapping']>;
+    type lengthChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['length']>;
+    type maxRowsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['maxRows']>;
+    type messagesCustomChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['messagesCustom']>;
+    type placeholderChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['placeholder']>;
+    type rawValueChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['rawValue']>;
+    type readonlyChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['readonly']>;
+    type requiredChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['required']>;
+    type requiredMessageDetailChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['requiredMessageDetail']>;
+    type resizeBehaviorChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['resizeBehavior']>;
+    type rowsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['rows']>;
+    type textAlignChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['textAlign']>;
+    type userAssistanceDensityChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['userAssistanceDensity']>;
+    type validChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['valid']>;
+    type validatorsChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['validators']>;
+    type valueChanged<V> = JetElementCustomEventStrict<CTextAreaElement<V>['value']>;
+}
+export interface CTextAreaElementEventMap<V> extends HTMLElementEventMap {
+    'autocompleteChanged': JetElementCustomEventStrict<CTextAreaElement<V>['autocomplete']>;
+    'containerReadonlyChanged': JetElementCustomEventStrict<CTextAreaElement<V>['containerReadonly']>;
+    'converterChanged': JetElementCustomEventStrict<CTextAreaElement<V>['converter']>;
+    'disabledChanged': JetElementCustomEventStrict<CTextAreaElement<V>['disabled']>;
+    'displayOptionsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['displayOptions']>;
+    'helpChanged': JetElementCustomEventStrict<CTextAreaElement<V>['help']>;
+    'helpHintsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['helpHints']>;
+    'labelEdgeChanged': JetElementCustomEventStrict<CTextAreaElement<V>['labelEdge']>;
+    'labelHintChanged': JetElementCustomEventStrict<CTextAreaElement<V>['labelHint']>;
+    'labelStartWidthChanged': JetElementCustomEventStrict<CTextAreaElement<V>['labelStartWidth']>;
+    'labelWrappingChanged': JetElementCustomEventStrict<CTextAreaElement<V>['labelWrapping']>;
+    'lengthChanged': JetElementCustomEventStrict<CTextAreaElement<V>['length']>;
+    'maxRowsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['maxRows']>;
+    'messagesCustomChanged': JetElementCustomEventStrict<CTextAreaElement<V>['messagesCustom']>;
+    'placeholderChanged': JetElementCustomEventStrict<CTextAreaElement<V>['placeholder']>;
+    'rawValueChanged': JetElementCustomEventStrict<CTextAreaElement<V>['rawValue']>;
+    'readonlyChanged': JetElementCustomEventStrict<CTextAreaElement<V>['readonly']>;
+    'requiredChanged': JetElementCustomEventStrict<CTextAreaElement<V>['required']>;
+    'requiredMessageDetailChanged': JetElementCustomEventStrict<CTextAreaElement<V>['requiredMessageDetail']>;
+    'resizeBehaviorChanged': JetElementCustomEventStrict<CTextAreaElement<V>['resizeBehavior']>;
+    'rowsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['rows']>;
+    'textAlignChanged': JetElementCustomEventStrict<CTextAreaElement<V>['textAlign']>;
+    'userAssistanceDensityChanged': JetElementCustomEventStrict<CTextAreaElement<V>['userAssistanceDensity']>;
+    'validChanged': JetElementCustomEventStrict<CTextAreaElement<V>['valid']>;
+    'validatorsChanged': JetElementCustomEventStrict<CTextAreaElement<V>['validators']>;
+    'valueChanged': JetElementCustomEventStrict<CTextAreaElement<V>['value']>;
+}
+export interface CTextAreaElementSettableProperties<V> extends JetSettableProperties {
+    autocomplete?: Props<V>['autocomplete'];
+    containerReadonly?: Props<V>['containerReadonly'];
+    converter?: Props<V>['converter'];
+    disabled?: Props<V>['disabled'];
+    displayOptions?: Props<V>['displayOptions'];
+    help?: Props<V>['help'];
+    helpHints?: Props<V>['helpHints'];
+    labelEdge?: Props<V>['labelEdge'];
+    labelHint: Props<V>['labelHint'];
+    labelStartWidth?: Props<V>['labelStartWidth'];
+    labelWrapping?: Props<V>['labelWrapping'];
+    length?: Props<V>['length'];
+    maxRows?: Props<V>['maxRows'];
+    messagesCustom?: Props<V>['messagesCustom'];
+    placeholder?: Props<V>['placeholder'];
+    readonly?: Props<V>['readonly'];
+    required?: Props<V>['required'];
+    requiredMessageDetail?: Props<V>['requiredMessageDetail'];
+    resizeBehavior?: Props<V>['resizeBehavior'];
+    rows?: Props<V>['rows'];
+    textAlign?: Props<V>['textAlign'];
+    userAssistanceDensity?: Props<V>['userAssistanceDensity'];
+    validators?: Props<V>['validators'];
+    value?: Props<V>['value'];
+}
+export interface CTextAreaElementSettablePropertiesLenient<V> extends Partial<CTextAreaElementSettableProperties<V>> {
+    [key: string]: any;
+}
+export interface TextAreaIntrinsicProps extends Partial<Readonly<CTextAreaElementSettableProperties<any>>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    rawValue?: never;
+    valid?: never;
+    onautocompleteChanged?: (value: CTextAreaElementEventMap<any>['autocompleteChanged']) => void;
+    oncontainerReadonlyChanged?: (value: CTextAreaElementEventMap<any>['containerReadonlyChanged']) => void;
+    onconverterChanged?: (value: CTextAreaElementEventMap<any>['converterChanged']) => void;
+    ondisabledChanged?: (value: CTextAreaElementEventMap<any>['disabledChanged']) => void;
+    ondisplayOptionsChanged?: (value: CTextAreaElementEventMap<any>['displayOptionsChanged']) => void;
+    onhelpChanged?: (value: CTextAreaElementEventMap<any>['helpChanged']) => void;
+    onhelpHintsChanged?: (value: CTextAreaElementEventMap<any>['helpHintsChanged']) => void;
+    onlabelEdgeChanged?: (value: CTextAreaElementEventMap<any>['labelEdgeChanged']) => void;
+    onlabelHintChanged?: (value: CTextAreaElementEventMap<any>['labelHintChanged']) => void;
+    onlabelStartWidthChanged?: (value: CTextAreaElementEventMap<any>['labelStartWidthChanged']) => void;
+    onlabelWrappingChanged?: (value: CTextAreaElementEventMap<any>['labelWrappingChanged']) => void;
+    onlengthChanged?: (value: CTextAreaElementEventMap<any>['lengthChanged']) => void;
+    onmaxRowsChanged?: (value: CTextAreaElementEventMap<any>['maxRowsChanged']) => void;
+    onmessagesCustomChanged?: (value: CTextAreaElementEventMap<any>['messagesCustomChanged']) => void;
+    onplaceholderChanged?: (value: CTextAreaElementEventMap<any>['placeholderChanged']) => void;
+    onrawValueChanged?: (value: CTextAreaElementEventMap<any>['rawValueChanged']) => void;
+    onreadonlyChanged?: (value: CTextAreaElementEventMap<any>['readonlyChanged']) => void;
+    onrequiredChanged?: (value: CTextAreaElementEventMap<any>['requiredChanged']) => void;
+    onrequiredMessageDetailChanged?: (value: CTextAreaElementEventMap<any>['requiredMessageDetailChanged']) => void;
+    onresizeBehaviorChanged?: (value: CTextAreaElementEventMap<any>['resizeBehaviorChanged']) => void;
+    onrowsChanged?: (value: CTextAreaElementEventMap<any>['rowsChanged']) => void;
+    ontextAlignChanged?: (value: CTextAreaElementEventMap<any>['textAlignChanged']) => void;
+    onuserAssistanceDensityChanged?: (value: CTextAreaElementEventMap<any>['userAssistanceDensityChanged']) => void;
+    onvalidChanged?: (value: CTextAreaElementEventMap<any>['validChanged']) => void;
+    onvalidatorsChanged?: (value: CTextAreaElementEventMap<any>['validatorsChanged']) => void;
+    onvalueChanged?: (value: CTextAreaElementEventMap<any>['valueChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-text-area': TextAreaIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+import { ComponentProps } from 'preact';
+import type { TextArea } from 'oj-c/text-area';
+declare 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): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    textAreaProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        autoComplete?: string | undefined;
+        autoFocus?: boolean | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "start" | "none" | "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?: string | undefined;
+        textAlign?: "start" | "right" | "end" | 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"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

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

@@ -0,0 +1,44 @@
+import { ComponentProps } from 'preact';
+import type { TextArea } from 'oj-c/text-area';
+declare 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): {
+    value: V;
+    setValue: import("preact/hooks").StateUpdater<V>;
+    methods: {
+        reset: () => void;
+        validate: () => Promise<"valid" | "invalid">;
+        showMessages: () => void;
+    };
+    textAreaProps: Omit<{
+        ariaDescribedBy?: string | undefined;
+        assistiveText?: string | undefined;
+        autoComplete?: string | undefined;
+        autoFocus?: boolean | undefined;
+        helpSourceLink?: string | undefined;
+        helpSourceText?: string | undefined;
+        isDisabled?: boolean | undefined;
+        isReadonly?: boolean | undefined;
+        isRequired?: boolean | undefined;
+        isRequiredShown?: boolean | undefined;
+        label: string;
+        labelEdge?: "start" | "none" | "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?: "vertical" | "horizontal" | "both" | undefined;
+        role?: string | undefined;
+        rows?: number | undefined;
+        textAlign?: "start" | "right" | "end" | 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"> & {
+        ref?: import("preact").Ref<import("@oracle/oraclejet-preact/hooks/UNSAFE_useFocusableTextField").FocusableHandle> | undefined;
+    };
+};
+export {};

package/oj-c/types/utils/UNSAFE_focusTabUtils/focusUtils.d.ts

@@ -0,0 +1,2 @@
+export declare const focusFirstTabStop: (element: HTMLElement | null) => HTMLElement | null | undefined;
+export declare const getFirstTabStop: (element: HTMLElement) => HTMLElement | null;

package/oj-c/types/utils/UNSAFE_focusTabUtils/index.d.ts

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

package/oj-c/types/utils/UNSAFE_keyUtils/index.d.ts

@@ -0,0 +1 @@
+export * from './keySetUtils';

package/oj-c/types/utils/UNSAFE_keyUtils/keySetUtils.d.ts

@@ -0,0 +1,4 @@
+import { ImmutableKeySet } from 'ojs/ojkeyset';
+import { Keys } from '@oracle/oraclejet-preact/utils/UNSAFE_keys';
+export declare const keySetToKeys: <K>(keySet: ImmutableKeySet<K> | undefined) => Keys<K>;
+export declare const keysToKeySet: <K>(keys: Keys<K>) => ImmutableKeySet<K>;

package/oj-c/types/utils/UNSAFE_meterUtils/index.d.ts

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

package/oj-c/types/utils/UNSAFE_meterUtils/meterUtils.d.ts

@@ -0,0 +1,2 @@
+import { Threshold } from '@oracle/oraclejet-preact/utils/UNSAFE_meterTypes';
+export declare const getThresholdColorByIndex: (threshold: Threshold, index: number) => string;

package/oj-c/utils/UNSAFE_focusTabUtils/focusUtils.js

@@ -0,0 +1,23 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getFirstTabStop = exports.focusFirstTabStop = void 0;
+    const focusFirstTabStop = (element) => {
+        if (!element)
+            return;
+        const focusElement = (0, exports.getFirstTabStop)(element);
+        if (focusElement) {
+            focusElement.focus();
+        }
+        return focusElement;
+    };
+    exports.focusFirstTabStop = focusFirstTabStop;
+    const getFirstTabStop = (element) => {
+        const tabbable = element.querySelectorAll('button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])');
+        if (tabbable && tabbable.length > 0) {
+            return tabbable[0];
+        }
+        return null;
+    };
+    exports.getFirstTabStop = getFirstTabStop;
+});

package/oj-c/utils/UNSAFE_focusTabUtils/index.js

@@ -0,0 +1,6 @@
+define(["require", "exports", "./focusUtils"], function (require, exports, focusUtils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.focusFirstTabStop = void 0;
+    Object.defineProperty(exports, "focusFirstTabStop", { enumerable: true, get: function () { return focusUtils_1.focusFirstTabStop; } });
+});

package/oj-c/utils/UNSAFE_keyUtils/index.js

@@ -0,0 +1,19 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+define(["require", "exports", "./keySetUtils"], function (require, exports, keySetUtils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(keySetUtils_1, exports);
+});

package/oj-c/utils/UNSAFE_keyUtils/keySetUtils.js

@@ -0,0 +1,33 @@
+define(["require", "exports", "ojs/ojkeyset"], function (require, exports, ojkeyset_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.keysToKeySet = exports.keySetToKeys = void 0;
+    const keySetToKeys = (keySet) => {
+        if (!keySet) {
+            return { all: false, keys: new Set() };
+        }
+        let keys = {};
+        if (keySet.isAddAll()) {
+            const deletedValues = new Set(keySet.deletedValues());
+            keys = { all: true, deletedKeys: deletedValues };
+        }
+        else if (!keySet.isAddAll()) {
+            const values = new Set(keySet.values());
+            keys = { all: false, keys: values };
+        }
+        return keys;
+    };
+    exports.keySetToKeys = keySetToKeys;
+    const keysToKeySet = (keys) => {
+        let keySet;
+        if (keys.all) {
+            keySet = new ojkeyset_1.AllKeySetImpl();
+            keySet.delete(new Set(keys.deletedKeys.values()));
+        }
+        else if (!keys.all) {
+            keySet = new ojkeyset_1.KeySetImpl(new Set(keys.keys.values()));
+        }
+        return keySet;
+    };
+    exports.keysToKeySet = keysToKeySet;
+});

package/oj-c/utils/UNSAFE_meterUtils/index.js

@@ -0,0 +1,6 @@
+define(["require", "exports", "./meterUtils"], function (require, exports, meterUtils_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getThresholdColorByIndex = void 0;
+    Object.defineProperty(exports, "getThresholdColorByIndex", { enumerable: true, get: function () { return meterUtils_1.getThresholdColorByIndex; } });
+});

package/oj-c/utils/UNSAFE_meterUtils/meterUtils.js

@@ -0,0 +1,12 @@
+define(["require", "exports"], function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getThresholdColorByIndex = void 0;
+    const THRESHOLD_COLORS = ['#D63B25', '#CF7C00', '#508223'];
+    const getThresholdColorByIndex = (threshold, index) => {
+        if (threshold.color)
+            return threshold.color;
+        return THRESHOLD_COLORS[index % THRESHOLD_COLORS.length];
+    };
+    exports.getThresholdColorByIndex = getThresholdColorByIndex;
+});

package/oj-c/utils/component.json

@@ -0,0 +1,9 @@
+{
+  "name": "utils",
+  "version": "1.0.0",
+  "jetVersion": "^13.0.0",
+  "type": "resource",
+  "displayName": "A user friendly, translatable name of the pack.",
+  "description": "A translatable high-level description for the pack.",
+  "pack": "oj-c"
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@oracle/oraclejet-core-pack",
+  "oracle-exchange": "oj-c",
+  "version": "14.0.0",
+  "description": "JET core components fully implemented in VDOM",
+  "types": "./types",
+  "keywords": [
+    "oraclejet"
+  ],
+  "license": "UPL-1.0",
+  "dependencies": {
+    "@oracle/oraclejet": "14.0.0",
+    "@oracle/oraclejet-webdriver": "14.0.0"
+  },
+  "peerDependencies": {
+    "selenium-webdriver": ">=3.6.0"
+  },
+  "files": [
+    "**",
+    "!**/test.page.*"
+  ]
+}

package/webdriver/docs/.nojekyll

@@ -0,0 +1 @@
+TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.