@oracle/oraclejet-core-pack 14.0.0

package/oj-c/text-area/text-area.js

@@ -0,0 +1,138 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+define(["require", "exports", "preact/jsx-runtime", '@oracle/oraclejet-preact/translationBundle', "@oracle/oraclejet-preact/hooks/UNSAFE_useFormContext", "@oracle/oraclejet-preact/hooks/UNSAFE_useFormVariantContext", "@oracle/oraclejet-preact/hooks/UNSAFE_useTabbableMode", "@oracle/oraclejet-preact/UNSAFE_TextArea", "@oracle/oraclejet-preact/UNSAFE_TextAreaAutosize", "oj-c/editable-value/UNSAFE_useAssistiveText/useAssistiveText", "ojs/ojcontext", "ojs/ojvcomponent", "ojs/ojvcomponent-binding", "preact", "preact/compat", "preact/hooks", "./useTextAreaAutosizePreact", "./useTextAreaPreact", "css!oj-c/text-area/text-area-styles.css"], function (require, exports, jsx_runtime_1, translationBundle_1, UNSAFE_useFormContext_1, UNSAFE_useFormVariantContext_1, UNSAFE_useTabbableMode_1, UNSAFE_TextArea_1, UNSAFE_TextAreaAutosize_1, useAssistiveText_1, ojcontext_1, ojvcomponent_1, ojvcomponent_binding_1, preact_1, compat_1, hooks_1, useTextAreaAutosizePreact_1, useTextAreaPreact_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TextArea = void 0;
+    translationBundle_1 = __importDefault(translationBundle_1);
+    ojcontext_1 = __importDefault(ojcontext_1);
+    const FunctionalTextArea = (0, compat_1.forwardRef)((props, ref) => {
+        const { busyContextRef, converter, displayOptions, help, helpHints, validators } = props;
+        const textAreaRef = (0, hooks_1.useRef)();
+        const addBusyState = (0, hooks_1.useCallback)((desc) => {
+            var _a;
+            return (_a = busyContextRef.current) === null || _a === void 0 ? void 0 : _a.addBusyState({
+                description: `oj-c-text-area id=${props.id} is ${desc}`
+            });
+        }, []);
+        const { textAreaProps, methods } = (0, useTextAreaPreact_1.useTextAreaPreact)(props, addBusyState);
+        (0, hooks_1.useImperativeHandle)(ref, () => (Object.assign({ blur: () => { var _a; return (_a = textAreaRef.current) === null || _a === void 0 ? void 0 : _a.blur(); }, focus: () => { var _a; return (_a = textAreaRef.current) === null || _a === void 0 ? void 0 : _a.focus(); } }, methods)), [methods]);
+        const assistiveTextProps = (0, useAssistiveText_1.useAssistiveText)({
+            converter,
+            displayOptions,
+            help,
+            helpHints,
+            validators
+        });
+        const variant = (0, UNSAFE_useFormVariantContext_1.useFormVariantContext)();
+        return ((0, jsx_runtime_1.jsx)(UNSAFE_TextArea_1.TextArea, Object.assign({ ref: textAreaRef }, assistiveTextProps, textAreaProps, { variant: variant })));
+    });
+    const FunctionalTextAreaAutosize = (0, compat_1.forwardRef)((props, ref) => {
+        const { busyContextRef, converter, help, helpHints, validators } = props;
+        const textAreaAutosizeRef = (0, hooks_1.useRef)();
+        const addBusyState = (0, hooks_1.useCallback)((desc) => {
+            var _a;
+            return (_a = busyContextRef.current) === null || _a === void 0 ? void 0 : _a.addBusyState({
+                description: `oj-c-text-area id=${props.id} is ${desc}`
+            });
+        }, []);
+        const { textAreaProps, methods } = (0, useTextAreaAutosizePreact_1.useTextAreaAutosizePreact)(props, addBusyState);
+        (0, hooks_1.useImperativeHandle)(ref, () => (Object.assign({ blur: () => { var _a; return (_a = textAreaAutosizeRef.current) === null || _a === void 0 ? void 0 : _a.blur(); }, focus: () => { var _a; return (_a = textAreaAutosizeRef.current) === null || _a === void 0 ? void 0 : _a.focus(); } }, methods)), [methods]);
+        const assistiveTextProps = (0, useAssistiveText_1.useAssistiveText)({
+            converter,
+            help,
+            helpHints,
+            validators
+        });
+        const variant = (0, UNSAFE_useFormVariantContext_1.useFormVariantContext)();
+        return ((0, jsx_runtime_1.jsx)(UNSAFE_TextAreaAutosize_1.TextAreaAutosize, Object.assign({ ref: textAreaAutosizeRef }, assistiveTextProps, textAreaProps, { variant: variant })));
+    });
+    let TextArea = class TextArea extends preact_1.Component {
+        constructor() {
+            super(...arguments);
+            this.busyContextRef = (0, preact_1.createRef)();
+            this.textAreaRef = (0, preact_1.createRef)();
+            this.rootRef = (0, preact_1.createRef)();
+        }
+        componentDidMount() {
+            this.busyContextRef.current = ojcontext_1.default.getContext(this.rootRef.current).getBusyContext();
+        }
+        render(props) {
+            const containerProps = {
+                isFormLayout: props.containerReadonly !== undefined,
+                isReadonly: props.containerReadonly,
+                labelWrapping: props.labelWrapping
+            };
+            const FunctionalComp = props.maxRows ? FunctionalTextAreaAutosize : FunctionalTextArea;
+            return ((0, jsx_runtime_1.jsx)(ojvcomponent_1.Root, Object.assign({ id: props.id, ref: this.rootRef }, { children: (0, jsx_runtime_1.jsx)(UNSAFE_useFormContext_1.FormContext.Provider, Object.assign({ value: containerProps }, { children: (0, jsx_runtime_1.jsx)(FunctionalComp, Object.assign({ busyContextRef: this.busyContextRef, ref: this.textAreaRef }, props)) })) })));
+        }
+        componentWillUnmount() {
+            this.busyContextRef.current = null;
+        }
+        reset() {
+            var _a;
+            (_a = this.textAreaRef.current) === null || _a === void 0 ? void 0 : _a.reset();
+        }
+        showMessages() {
+            var _a;
+            (_a = this.textAreaRef.current) === null || _a === void 0 ? void 0 : _a.showMessages();
+        }
+        validate() {
+            var _a;
+            return (_a = this.textAreaRef.current) === null || _a === void 0 ? void 0 : _a.validate();
+        }
+        blur() {
+            var _a;
+            (_a = this.textAreaRef.current) === null || _a === void 0 ? void 0 : _a.blur();
+        }
+        focus() {
+            var _a;
+            (_a = this.textAreaRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }
+    };
+    TextArea.defaultProps = {
+        autocomplete: 'on',
+        converter: null,
+        disabled: false,
+        displayOptions: {
+            converterHint: 'display',
+            messages: 'display',
+            validatorHint: 'display'
+        },
+        help: {
+            instruction: ''
+        },
+        helpHints: {
+            definition: '',
+            source: '',
+            sourceText: undefined
+        },
+        length: {
+            countBy: 'codePoint',
+            max: null
+        },
+        messagesCustom: [],
+        readonly: false,
+        required: false,
+        resizeBehavior: 'none',
+        userAssistanceDensity: 'reflow',
+        validators: [],
+        value: null
+    };
+    TextArea._metadata = { "properties": { "autocomplete": { "type": "string" }, "containerReadonly": { "type": "boolean", "binding": { "consume": { "name": "containerReadonly" } } }, "converter": { "type": "object|null" }, "disabled": { "type": "boolean" }, "displayOptions": { "type": "object", "properties": { "converterHint": { "type": "string", "enumValues": ["display", "none"] }, "messages": { "type": "string", "enumValues": ["display", "none"] }, "validatorHint": { "type": "string", "enumValues": ["display", "none"] } } }, "help": { "type": "object", "properties": { "instruction": { "type": "string" } } }, "helpHints": { "type": "object", "properties": { "definition": { "type": "string" }, "source": { "type": "string" }, "sourceText": { "type": "string" } } }, "labelEdge": { "type": "string", "enumValues": ["start", "none", "top", "inside"], "binding": { "consume": { "name": "containerLabelEdge" } } }, "labelHint": { "type": "string" }, "labelStartWidth": { "type": "string", "binding": { "consume": { "name": "labelWidth" } } }, "labelWrapping": { "type": "string", "enumValues": ["wrap", "truncate"], "binding": { "consume": { "name": "labelWrapping" } } }, "length": { "type": "object", "properties": { "countBy": { "type": "string", "enumValues": ["codePoint", "codeUnit"] }, "counter": { "type": "string", "enumValues": ["none", "remaining"] }, "max": { "type": "number|null" } } }, "maxRows": { "type": "number" }, "messagesCustom": { "type": "Array<object>", "writeback": true }, "placeholder": { "type": "string" }, "readonly": { "type": "boolean", "binding": { "consume": { "name": "containerReadonly" } } }, "required": { "type": "boolean" }, "requiredMessageDetail": { "type": "string" }, "resizeBehavior": { "type": "string", "enumValues": ["none", "vertical", "horizontal", "both"] }, "rows": { "type": "number" }, "textAlign": { "type": "string", "enumValues": ["start", "right", "end"] }, "userAssistanceDensity": { "type": "string", "enumValues": ["reflow", "efficient"], "binding": { "consume": { "name": "containerUserAssistanceDensity" } } }, "validators": { "type": "Array<object>|null" }, "value": { "type": "any", "writeback": true }, "rawValue": { "type": "string", "readOnly": true, "writeback": true }, "valid": { "type": "string", "enumValues": ["valid", "pending", "invalidHidden", "invalidShown"], "readOnly": true, "writeback": true } }, "extension": { "_WRITEBACK_PROPS": ["messagesCustom", "rawValue", "valid", "value"], "_READ_ONLY_PROPS": ["rawValue", "valid"], "_OBSERVED_GLOBAL_PROPS": ["aria-describedby", "autofocus", "id"] }, "methods": { "reset": {}, "showMessages": {}, "validate": {}, "blur": {}, "focus": {} } };
+    TextArea._translationBundleMap = {
+        '@oracle/oraclejet-preact': translationBundle_1.default
+    };
+    TextArea._consumedContexts = [UNSAFE_useFormVariantContext_1.FormVariantContext, UNSAFE_useTabbableMode_1.TabbableModeContext];
+    TextArea = __decorate([
+        (0, ojvcomponent_1.customElement)('oj-c-text-area')
+    ], TextArea);
+    exports.TextArea = TextArea;
+});

package/oj-c/text-area/useTextAreaAutosizePreact.js

@@ -0,0 +1,44 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+define(["require", "exports", "oj-c/editable-value/UNSAFE_useEditableValue/useEditableValue"], function (require, exports, useEditableValue_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useTextAreaAutosizePreact = void 0;
+    function useTextAreaAutosizePreact(_a, addBusyState) {
+        var { autocomplete = 'on', 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 } = _a, otherProps = __rest(_a, ["autocomplete", "autofocus", "converter", "disabled", "displayOptions", "labelEdge", "labelHint", "labelStartWidth", "length", "maxRows", "messagesCustom", "placeholder", "readonly", "required", "requiredMessageDetail", "resizeBehavior", "rows", "textAlign", "userAssistanceDensity", "validators", "value", "onMessagesCustomChanged", "onRawValueChanged", "onValidChanged", "onValueChanged"]);
+        const { methods, textFieldProps, value, setValue } = (0, useEditableValue_1.useEditableValue)({
+            ariaDescribedBy: otherProps['aria-describedby'],
+            converter,
+            displayOptions,
+            messagesCustom,
+            required,
+            requiredMessageDetail,
+            validators,
+            value: propValue,
+            addBusyState,
+            onMessagesCustomChanged,
+            onRawValueChanged,
+            onValidChanged,
+            onValueChanged
+        });
+        const hasNoValue = value === null || (typeof value === 'string' && value === '');
+        return {
+            value,
+            setValue,
+            methods,
+            textAreaProps: Object.assign({ autoComplete: autocomplete, autoFocus: autofocus, isDisabled: disabled, isReadonly: readonly, isRequired: required, isRequiredShown: required && hasNoValue, label: labelHint, labelEdge,
+                labelStartWidth, maxLength: (length === null || length === void 0 ? void 0 : length.max) ? length.max : undefined, maxLengthCounter: length === null || length === void 0 ? void 0 : length.counter, maxLengthUnit: length === null || length === void 0 ? void 0 : length.countBy, maxRows: maxRows === -1 ? undefined : maxRows, minRows: rows, placeholder, resize: resizeBehavior, textAlign,
+                userAssistanceDensity }, textFieldProps)
+        };
+    }
+    exports.useTextAreaAutosizePreact = useTextAreaAutosizePreact;
+});

package/oj-c/text-area/useTextAreaPreact.js

@@ -0,0 +1,46 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+define(["require", "exports", "oj-c/editable-value/UNSAFE_useEditableValue/useEditableValue"], function (require, exports, useEditableValue_1) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.useTextAreaPreact = void 0;
+    function useTextAreaPreact(_a, addBusyState) {
+        var { autocomplete = 'on', autofocus, converter, disabled, displayOptions, labelEdge, labelHint, labelStartWidth, length, messagesCustom, placeholder, readonly, required, requiredMessageDetail, resizeBehavior, rows, textAlign, userAssistanceDensity, validators, value: propValue, onMessagesCustomChanged, onRawValueChanged, onValueChanged, onValidChanged } = _a, otherProps = __rest(_a, ["autocomplete", "autofocus", "converter", "disabled", "displayOptions", "labelEdge", "labelHint", "labelStartWidth", "length", "messagesCustom", "placeholder", "readonly", "required", "requiredMessageDetail", "resizeBehavior", "rows", "textAlign", "userAssistanceDensity", "validators", "value", "onMessagesCustomChanged", "onRawValueChanged", "onValueChanged", "onValidChanged"]);
+        const { methods, textFieldProps, value, setValue } = (0, useEditableValue_1.useEditableValue)({
+            ariaDescribedBy: otherProps['aria-describedby'],
+            converter,
+            displayOptions,
+            messagesCustom,
+            required,
+            requiredMessageDetail,
+            validators,
+            value: propValue,
+            addBusyState,
+            onMessagesCustomChanged,
+            onRawValueChanged,
+            onValidChanged,
+            onValueChanged
+        });
+        const hasNoValue = value === null || (typeof value === 'string' && value === '');
+        return {
+            value,
+            setValue,
+            methods,
+            textAreaProps: Object.assign({ autoComplete: autocomplete, autoFocus: autofocus, isDisabled: disabled, isReadonly: readonly, isRequired: required, isRequiredShown: required && hasNoValue, label: labelHint, labelEdge,
+                labelStartWidth, maxLength: (length === null || length === void 0 ? void 0 : length.max) ? length.max : undefined, maxLengthUnit: length === null || length === void 0 ? void 0 : length.countBy, maxLengthCounter: length === null || length === void 0 ? void 0 : length.counter, resize: resizeBehavior != 'none' ? resizeBehavior : undefined, rows,
+                placeholder,
+                textAlign,
+                userAssistanceDensity }, textFieldProps)
+        };
+    }
+    exports.useTextAreaPreact = useTextAreaPreact;
+});

package/oj-c/text-area.js

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

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

@@ -0,0 +1,68 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { Avatar as PreactAvatar } from '@oracle/oraclejet-preact/UNSAFE_Avatar';
+import { ComponentProps } from 'preact';
+import { ObservedGlobalProps } from 'ojs/ojvcomponent';
+import 'css!oj-c/avatar/avatar-styles.css';
+declare type PreactAvatarProps = ComponentProps<typeof PreactAvatar>;
+export declare const Avatar: import("preact").ComponentType<import("ojs/ojvcomponent").ExtendGlobalProps<ObservedGlobalProps<"aria-label"> & {
+    background?: PreactAvatarProps['background'];
+    initials?: string | null | undefined;
+    size?: PreactAvatarProps['size'];
+    src?: string | null | undefined;
+    iconClass?: string | undefined;
+    shape?: PreactAvatarProps['shape'];
+}>>;
+export {};
+export interface CAvatarElement extends JetElement<CAvatarElementSettableProperties>, CAvatarElementSettableProperties {
+    addEventListener<T extends keyof CAvatarElementEventMap>(type: T, listener: (this: HTMLElement, ev: CAvatarElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CAvatarElementSettableProperties>(property: T): CAvatarElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CAvatarElementSettableProperties>(property: T, value: CAvatarElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CAvatarElementSettableProperties>): void;
+    setProperties(properties: CAvatarElementSettablePropertiesLenient): void;
+}
+export namespace CAvatarElement {
+    type backgroundChanged = JetElementCustomEventStrict<CAvatarElement['background']>;
+    type iconClassChanged = JetElementCustomEventStrict<CAvatarElement['iconClass']>;
+    type initialsChanged = JetElementCustomEventStrict<CAvatarElement['initials']>;
+    type shapeChanged = JetElementCustomEventStrict<CAvatarElement['shape']>;
+    type sizeChanged = JetElementCustomEventStrict<CAvatarElement['size']>;
+    type srcChanged = JetElementCustomEventStrict<CAvatarElement['src']>;
+}
+export interface CAvatarElementEventMap extends HTMLElementEventMap {
+    'backgroundChanged': JetElementCustomEventStrict<CAvatarElement['background']>;
+    'iconClassChanged': JetElementCustomEventStrict<CAvatarElement['iconClass']>;
+    'initialsChanged': JetElementCustomEventStrict<CAvatarElement['initials']>;
+    'shapeChanged': JetElementCustomEventStrict<CAvatarElement['shape']>;
+    'sizeChanged': JetElementCustomEventStrict<CAvatarElement['size']>;
+    'srcChanged': JetElementCustomEventStrict<CAvatarElement['src']>;
+}
+export interface CAvatarElementSettableProperties extends JetSettableProperties {
+    background?: ComponentProps<typeof Avatar>['background'];
+    iconClass?: ComponentProps<typeof Avatar>['iconClass'];
+    initials?: ComponentProps<typeof Avatar>['initials'];
+    shape?: ComponentProps<typeof Avatar>['shape'];
+    size?: ComponentProps<typeof Avatar>['size'];
+    src?: ComponentProps<typeof Avatar>['src'];
+}
+export interface CAvatarElementSettablePropertiesLenient extends Partial<CAvatarElementSettableProperties> {
+    [key: string]: any;
+}
+export interface AvatarIntrinsicProps extends Partial<Readonly<CAvatarElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    onbackgroundChanged?: (value: CAvatarElementEventMap['backgroundChanged']) => void;
+    oniconClassChanged?: (value: CAvatarElementEventMap['iconClassChanged']) => void;
+    oninitialsChanged?: (value: CAvatarElementEventMap['initialsChanged']) => void;
+    onshapeChanged?: (value: CAvatarElementEventMap['shapeChanged']) => void;
+    onsizeChanged?: (value: CAvatarElementEventMap['sizeChanged']) => void;
+    onsrcChanged?: (value: CAvatarElementEventMap['srcChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-avatar': AvatarIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { Avatar } from './avatar';
+export { CAvatarElement } from './avatar';

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

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

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

@@ -0,0 +1,91 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { Button as PreactButton } from '@oracle/oraclejet-preact/UNSAFE_Button';
+import { ComponentProps, Component } from 'preact';
+import { ExtendGlobalProps, Action, Bubbles, ObservedGlobalProps, Slot } from 'ojs/ojvcomponent';
+import 'css!oj-c/button/button-styles.css';
+import { Size } from '@oracle/oraclejet-preact/utils/UNSAFE_size';
+declare type PreactButtonProps = ComponentProps<typeof PreactButton>;
+declare type Props = ObservedGlobalProps<'title' | 'aria-label'> & {
+    label: string;
+    startIcon?: Slot;
+    endIcon?: Slot;
+    disabled?: boolean;
+    width?: Size;
+    display?: PreactButtonProps['display'];
+    size?: PreactButtonProps['size'];
+    edge?: PreactButtonProps['edge'];
+    chroming?: PreactButtonProps['variant'];
+    onOjAction?: Action & Bubbles;
+};
+export declare class Button extends Component<ExtendGlobalProps<Props>> {
+    static defaultProps: Partial<Props>;
+    private buttonRef;
+    render(props: ExtendGlobalProps<Props>): import("preact").JSX.Element;
+    blur(): void;
+    focus(): void;
+}
+export {};
+export interface CButtonElement extends JetElement<CButtonElementSettableProperties>, CButtonElementSettableProperties {
+    addEventListener<T extends keyof CButtonElementEventMap>(type: T, listener: (this: HTMLElement, ev: CButtonElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CButtonElementSettableProperties>(property: T): CButtonElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CButtonElementSettableProperties>(property: T, value: CButtonElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CButtonElementSettableProperties>): void;
+    setProperties(properties: CButtonElementSettablePropertiesLenient): void;
+    blur: Button['blur'];
+    focus: Button['focus'];
+}
+export namespace CButtonElement {
+    interface ojAction extends CustomEvent<{}> {
+    }
+    type chromingChanged = JetElementCustomEventStrict<CButtonElement['chroming']>;
+    type disabledChanged = JetElementCustomEventStrict<CButtonElement['disabled']>;
+    type displayChanged = JetElementCustomEventStrict<CButtonElement['display']>;
+    type edgeChanged = JetElementCustomEventStrict<CButtonElement['edge']>;
+    type labelChanged = JetElementCustomEventStrict<CButtonElement['label']>;
+    type sizeChanged = JetElementCustomEventStrict<CButtonElement['size']>;
+    type widthChanged = JetElementCustomEventStrict<CButtonElement['width']>;
+}
+export interface CButtonElementEventMap extends HTMLElementEventMap {
+    'ojAction': CButtonElement.ojAction;
+    'chromingChanged': JetElementCustomEventStrict<CButtonElement['chroming']>;
+    'disabledChanged': JetElementCustomEventStrict<CButtonElement['disabled']>;
+    'displayChanged': JetElementCustomEventStrict<CButtonElement['display']>;
+    'edgeChanged': JetElementCustomEventStrict<CButtonElement['edge']>;
+    'labelChanged': JetElementCustomEventStrict<CButtonElement['label']>;
+    'sizeChanged': JetElementCustomEventStrict<CButtonElement['size']>;
+    'widthChanged': JetElementCustomEventStrict<CButtonElement['width']>;
+}
+export interface CButtonElementSettableProperties extends JetSettableProperties {
+    chroming?: Props['chroming'];
+    disabled?: Props['disabled'];
+    display?: Props['display'];
+    edge?: Props['edge'];
+    label: Props['label'];
+    size?: Props['size'];
+    width?: Props['width'];
+}
+export interface CButtonElementSettablePropertiesLenient extends Partial<CButtonElementSettableProperties> {
+    [key: string]: any;
+}
+export interface ButtonIntrinsicProps extends Partial<Readonly<CButtonElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojAction?: (value: CButtonElementEventMap['ojAction']) => void;
+    onchromingChanged?: (value: CButtonElementEventMap['chromingChanged']) => void;
+    ondisabledChanged?: (value: CButtonElementEventMap['disabledChanged']) => void;
+    ondisplayChanged?: (value: CButtonElementEventMap['displayChanged']) => void;
+    onedgeChanged?: (value: CButtonElementEventMap['edgeChanged']) => void;
+    onlabelChanged?: (value: CButtonElementEventMap['labelChanged']) => void;
+    onsizeChanged?: (value: CButtonElementEventMap['sizeChanged']) => void;
+    onwidthChanged?: (value: CButtonElementEventMap['widthChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-button': ButtonIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { Button } from './button';
+export { CButtonElement } from './button';

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

@@ -0,0 +1,88 @@
+import { JetElement, JetSettableProperties, JetElementCustomEventStrict, JetSetPropertyType } from 'ojs/index';
+import { GlobalProps } from 'ojs/ojvcomponent';
+import 'ojs/oj-jsx-interfaces';
+import { ComponentChildren, ComponentType } from 'preact';
+import { Action, CancelableAction, ExtendGlobalProps, PropertyChanged, Slot, ObservedGlobalProps } from 'ojs/ojvcomponent';
+import 'css!oj-c/collapsible/collapsible-styles.css';
+declare type ToggleDetail = {
+    target: EventTarget | null;
+};
+declare type Props = ObservedGlobalProps<'id'> & {
+    children: ComponentChildren;
+    disabled?: boolean;
+    expanded?: boolean;
+    iconPosition?: 'start' | 'end';
+    variant?: 'basic' | 'horizontal-rule';
+    header?: Slot;
+    onExpandedChanged?: PropertyChanged<boolean>;
+    onOjBeforeCollapse?: CancelableAction<ToggleDetail>;
+    onOjBeforeExpand?: CancelableAction<ToggleDetail>;
+    onOjCollapse?: Action<ToggleDetail>;
+    onOjExpand?: Action<ToggleDetail>;
+};
+export declare const Collapsible: ComponentType<ExtendGlobalProps<Props>>;
+export {};
+export interface CCollapsibleElement extends JetElement<CCollapsibleElementSettableProperties>, CCollapsibleElementSettableProperties {
+    addEventListener<T extends keyof CCollapsibleElementEventMap>(type: T, listener: (this: HTMLElement, ev: CCollapsibleElementEventMap[T]) => any, options?: (boolean | AddEventListenerOptions)): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: (boolean | AddEventListenerOptions)): void;
+    getProperty<T extends keyof CCollapsibleElementSettableProperties>(property: T): CCollapsibleElement[T];
+    getProperty(property: string): any;
+    setProperty<T extends keyof CCollapsibleElementSettableProperties>(property: T, value: CCollapsibleElementSettableProperties[T]): void;
+    setProperty<T extends string>(property: T, value: JetSetPropertyType<T, CCollapsibleElementSettableProperties>): void;
+    setProperties(properties: CCollapsibleElementSettablePropertiesLenient): void;
+}
+export namespace CCollapsibleElement {
+    interface ojBeforeCollapse extends CustomEvent<ToggleDetail & {
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojBeforeExpand extends CustomEvent<ToggleDetail & {
+        accept: (param: Promise<void>) => void;
+    }> {
+    }
+    interface ojCollapse extends CustomEvent<ToggleDetail & {}> {
+    }
+    interface ojExpand extends CustomEvent<ToggleDetail & {}> {
+    }
+    type disabledChanged = JetElementCustomEventStrict<CCollapsibleElement['disabled']>;
+    type expandedChanged = JetElementCustomEventStrict<CCollapsibleElement['expanded']>;
+    type iconPositionChanged = JetElementCustomEventStrict<CCollapsibleElement['iconPosition']>;
+    type variantChanged = JetElementCustomEventStrict<CCollapsibleElement['variant']>;
+}
+export interface CCollapsibleElementEventMap extends HTMLElementEventMap {
+    'ojBeforeCollapse': CCollapsibleElement.ojBeforeCollapse;
+    'ojBeforeExpand': CCollapsibleElement.ojBeforeExpand;
+    'ojCollapse': CCollapsibleElement.ojCollapse;
+    'ojExpand': CCollapsibleElement.ojExpand;
+    'disabledChanged': JetElementCustomEventStrict<CCollapsibleElement['disabled']>;
+    'expandedChanged': JetElementCustomEventStrict<CCollapsibleElement['expanded']>;
+    'iconPositionChanged': JetElementCustomEventStrict<CCollapsibleElement['iconPosition']>;
+    'variantChanged': JetElementCustomEventStrict<CCollapsibleElement['variant']>;
+}
+export interface CCollapsibleElementSettableProperties extends JetSettableProperties {
+    disabled?: Props['disabled'];
+    expanded?: Props['expanded'];
+    iconPosition?: Props['iconPosition'];
+    variant?: Props['variant'];
+}
+export interface CCollapsibleElementSettablePropertiesLenient extends Partial<CCollapsibleElementSettableProperties> {
+    [key: string]: any;
+}
+export interface CollapsibleIntrinsicProps extends Partial<Readonly<CCollapsibleElementSettableProperties>>, GlobalProps, Pick<preact.JSX.HTMLAttributes, 'ref' | 'key'> {
+    children?: import('preact').ComponentChildren;
+    onojBeforeCollapse?: (value: CCollapsibleElementEventMap['ojBeforeCollapse']) => void;
+    onojBeforeExpand?: (value: CCollapsibleElementEventMap['ojBeforeExpand']) => void;
+    onojCollapse?: (value: CCollapsibleElementEventMap['ojCollapse']) => void;
+    onojExpand?: (value: CCollapsibleElementEventMap['ojExpand']) => void;
+    ondisabledChanged?: (value: CCollapsibleElementEventMap['disabledChanged']) => void;
+    onexpandedChanged?: (value: CCollapsibleElementEventMap['expandedChanged']) => void;
+    oniconPositionChanged?: (value: CCollapsibleElementEventMap['iconPositionChanged']) => void;
+    onvariantChanged?: (value: CCollapsibleElementEventMap['variantChanged']) => void;
+}
+declare global {
+    namespace preact.JSX {
+        interface IntrinsicElements {
+            'oj-c-collapsible': CollapsibleIntrinsicProps;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+export { Collapsible } from './collapsible';
+export { CCollapsibleElement } from './collapsible';

package/oj-c/types/editable-value/UNSAFE_useAssistiveText/useAssistiveText.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="ojconverter" />
+/// <reference types="ojvalidator" />
+/// <reference types="ojvalidator-async" />
+import Converter from 'ojs/ojconverter';
+import Validator from 'ojs/ojvalidator';
+import AsyncValidator from 'ojs/ojvalidator-async';
+export declare type DisplayOptions = {
+    converterHint?: 'display' | 'none';
+    messages?: 'display' | 'none';
+    validatorHint?: 'display' | 'none';
+};
+export declare type Help = {
+    instruction?: string;
+};
+export declare type HelpHints = {
+    definition?: string;
+    source?: string;
+    sourceText?: string;
+};
+export declare type UseAssistiveTextProps = {
+    addBusyState?: (desc: string) => () => void;
+    converter?: Converter<unknown>;
+    displayOptions?: DisplayOptions;
+    help?: Help;
+    helpHints?: HelpHints;
+    validators?: (Validator<unknown> | AsyncValidator<unknown>)[];
+};
+export declare function useAssistiveText({ addBusyState, converter, displayOptions, help, helpHints, validators }: UseAssistiveTextProps): {
+    assistiveText: string | undefined;
+    helpSourceLink: string | undefined;
+    helpSourceText: string | undefined;
+};

package/oj-c/types/editable-value/UNSAFE_useComponentMessaging/useComponentMessaging.d.ts

@@ -0,0 +1,24 @@
+import { ComponentMessageItem } from '@oracle/oraclejet-preact/UNSAFE_ComponentMessage';
+import { StateUpdater } from 'preact/hooks';
+export declare type ComponentMessagingState = {
+    componentMessages: ComponentMessageItem[];
+    deferredComponentMessages: ComponentMessageItem[];
+    messagesCustom: ComponentMessageItem[];
+    visibleMessages: ComponentMessageItem[];
+    addComponentMessage: (message: ComponentMessageItem) => void;
+    addDeferredComponentMessage: (message: ComponentMessageItem) => void;
+    clearAllComponentMessages: () => void;
+    clearAllMessages: () => void;
+    clearDeferredComponentMessages: () => void;
+    hasCustomErrorMessages: () => boolean;
+    hasHiddenMessages: () => boolean;
+    hasNoErrorMessages: () => boolean;
+    setComponentMessages: StateUpdater<ComponentMessageItem[]>;
+    setDeferredComponentMessages: StateUpdater<ComponentMessageItem[]>;
+    showHiddenMessages: () => void;
+};
+export declare type UseComponentMessagingProps = {
+    messagesCustom?: ComponentMessageItem[];
+    onMessagesCustomChanged?: (messagesCustom?: ComponentMessageItem[]) => void;
+};
+export declare function useComponentMessaging({ messagesCustom: messagesCustomProp, onMessagesCustomChanged }: UseComponentMessagingProps): ComponentMessagingState;

package/oj-c/types/editable-value/UNSAFE_useConverter/useConverter.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="ojconverter" />
+import Converter from 'ojs/ojconverter';
+import { ComponentMessagingState } from '../UNSAFE_useComponentMessaging/useComponentMessaging';
+import { ValidationState } from '../UNSAFE_useValidators/useValidators';
+export declare type UseConverterProps<V> = {
+    converter?: Converter<V>;
+    componentMessagingState: ComponentMessagingState;
+    validationState: ValidationState<V>;
+};
+export declare const ConverterErrorSymbol: unique symbol;
+export declare function useConverter<V>({ componentMessagingState, validationState, converter }: UseConverterProps<V>): {
+    format: (value: V, shouldSuppressError?: boolean) => string | null | undefined;
+    parse: (displayValue: string) => typeof ConverterErrorSymbol | V | null;
+};

package/oj-c/types/editable-value/UNSAFE_useConverterLifecycle/useConverterLifecycle.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="ojconverter" />
+import Converter from 'ojs/ojconverter';
+import { ValidationState } from '../UNSAFE_useValidators/useValidators';
+declare type UseConverterLifecycleProps<V> = {
+    converter?: Converter<V>;
+    validationState: ValidationState<V>;
+    refreshDisplayValue: () => void;
+    runFullValidationAndUpdateValue: () => Promise<void>;
+};
+export declare function useConverterLifecycle<V>({ converter, validationState, refreshDisplayValue, runFullValidationAndUpdateValue }: UseConverterLifecycleProps<V>): void;
+export {};

package/oj-c/types/editable-value/UNSAFE_useDeferredValidators/useDeferredValidators.d.ts

@@ -0,0 +1,8 @@
+import { ValidatorLike } from '../UNSAFE_useValidators/useValidators';
+declare type UseDeferredValidatorsProps = {
+    labelHint?: string;
+    required?: boolean;
+    requiredMessageDetail?: string;
+};
+export declare function useDeferredValidators<V>({ labelHint, required, requiredMessageDetail }: UseDeferredValidatorsProps): ValidatorLike<V>[];
+export {};