@oracle/oraclejet-preact 14.0.0

package/cjs/hooks/UNSAFE_useTextField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useTextField.js","sources":["../../../src/hooks/UNSAFE_useTextField/useTextField.ts"],"sourcesContent":["import { ComponentProps } from 'preact';\nimport { useMemo } from 'preact/hooks';\nimport { Label } from '../../UNSAFE_Label';\nimport { TextField } from '../../UNSAFE_TextField';\nimport { InlineUserAssistance } from '../../UNSAFE_UserAssistance';\nimport { FormFieldContextProps } from '../UNSAFE_useFormFieldContext';\nimport { useId } from '../UNSAFE_useId';\n\ntype PickedUserAssistanceProps = Pick<ComponentProps<typeof InlineUserAssistance>, 'messages'>;\n\ntype UseTextFieldProps<V> = PickedUserAssistanceProps & {\n  ariaDescribedBy?: string;\n  contentVariant?: 'input' | 'textarea';\n  isDisabled?: boolean;\n  isFocused?: boolean;\n  isLoading?: boolean;\n  isReadonly?: boolean;\n  labelEdge?: ComponentProps<typeof TextField>['labelEdge'] | 'none';\n  styleVariant?: 'default' | 'embedded';\n  value?: V;\n};\n\nconst rankedSeverities = ['error', 'warning', 'confirmation', 'info', 'none'] as const;\n\n/**\n * Merge multiple ids into a space-separated list\n * @param ids The ids to be merged\n * @returns The space separated string of ids\n */\nfunction mergeIDs(...ids: (string | undefined)[]) {\n  return ids.filter(Boolean).join(' ') || undefined;\n}\n\n/**\n * A custom hook to determine the props for a component that renders\n * a text field\n */\nexport function useTextField<V>({\n  ariaDescribedBy,\n  contentVariant,\n  isDisabled,\n  isFocused,\n  isLoading,\n  isReadonly,\n  labelEdge,\n  messages,\n  styleVariant,\n  value\n}: UseTextFieldProps<V>) {\n  const baseId = useId();\n  const labelId = labelEdge !== 'none' ? `${baseId}-label` : undefined;\n  const inputId = !isReadonly ? `${baseId}-input` : undefined;\n  const uaId = !(isDisabled || isReadonly) ? `${baseId}-ua` : undefined;\n\n  // Create the form field context\n  const formFieldContext = useMemo<FormFieldContextProps>(() => {\n    const hasValue = value !== undefined && (typeof value !== 'string' || value !== '');\n    return isReadonly\n      ? {\n          hasValue: hasValue,\n          isFocused: isFocused,\n          isLoading,\n          isReadonly: true\n        }\n      : isDisabled\n      ? {\n          hasValue: hasValue,\n          isDisabled: true,\n          isLoading\n        }\n      : {\n          hasValue: hasValue,\n          isFocused: isFocused,\n          isLoading\n        };\n  }, [isDisabled, isFocused, isLoading, isReadonly, value]);\n\n  // Determine the highest severity from the messages\n  const messageSeverity = useMemo(() => {\n    return messages === undefined\n      ? undefined\n      : messages.reduce<typeof rankedSeverities[number]>((accSeverity, currMessage) => {\n          const currSeverity = currMessage.severity || 'error';\n          return rankedSeverities.indexOf(accSeverity) < rankedSeverities.indexOf(currSeverity)\n            ? accSeverity\n            : currSeverity;\n        }, 'none');\n  }, [messages]);\n\n  // Determine the label variant\n  const labelVariant: ComponentProps<typeof Label>['variant'] =\n    labelEdge === 'inside'\n      ? messageSeverity === 'error'\n        ? 'insideError'\n        : messageSeverity === 'warning'\n        ? 'insideWarning'\n        : labelEdge\n      : labelEdge !== 'none'\n      ? labelEdge\n      : undefined;\n\n  return {\n    baseId,\n    formFieldContext,\n    inputProps: {\n      id: inputId,\n      ariaDescribedBy: mergeIDs(uaId, ariaDescribedBy),\n      ariaInvalid: messageSeverity === 'error' ? 'true' : undefined,\n      variant: styleVariant\n    },\n    labelProps: {\n      forId: inputId,\n      id: labelId,\n      variant: labelVariant\n    },\n    textFieldProps: {\n      contentVariant,\n      statusVariant: /error|warning/.test(messageSeverity ?? '')\n        ? (messageSeverity as 'error' | 'warning')\n        : undefined,\n      styleVariant\n    },\n    userAssistanceProps: {\n      id: uaId\n    }\n  };\n}\n"],"names":["useId","useMemo"],"mappings":"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"}

package/cjs/hooks/UNSAFE_useTextFieldInputHandlers.js

@@ -0,0 +1,94 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+require('../utils/PRIVATE_clientHints.js');
+var clientHints = require('../clientHints-78b0e917.js');
+
+function useTextFieldInputHandlers({ currentCommitValue, value, onInput, onCommit, onKeyDown }) {
+    const isComposing = hooks.useRef(false);
+    // preactjs/preact #1899 - https://github.com/preactjs/preact/issues/1899
+    // Preact does not force the native input to be controlled, so we need to
+    // trigger a rerender in order to keep it fully controlled.
+    // Force update hack is from https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate
+    const [, forceUpdate] = hooks.useReducer((x) => x + 1, 0);
+    // TODO: Currently, this assumes that the input field is a text field
+    // so that the change event can be simulated by capturing blur and enter keydown
+    // event. We might have to make this generic to handle other input types
+    // as well like radio, select, checkbox.
+    const handleChange = hooks.useCallback((event) => {
+        const currentValue = event.target.value;
+        // When do we *not* want to call onCommit?
+        // When the input's value
+        // is the same as the currentCommitValue (like if the user hits Enter over and over,
+        // or if the user focuses and blurs over and over).
+        // Or when the component's value is programmatically changed.
+        // (currentCommitValue is updated whenever we commit or get a programmatic change.
+        // See component code and useCurrentValueReducer hook)
+        // We only need to trigger an onCommit for user interacted changes, not programmatic changes
+        if (currentCommitValue !== currentValue) {
+            onCommit === null || onCommit === void 0 ? void 0 : onCommit({ previousValue: currentCommitValue, value: currentValue });
+        }
+    }, [onCommit, currentCommitValue]);
+    const handleKeyDown = hooks.useCallback((event) => {
+        onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);
+        if (event.key === 'Enter') {
+            handleChange(event);
+        }
+    }, [handleChange, onKeyDown]);
+    const handleCompositionStart = hooks.useCallback(() => {
+        isComposing.current = true;
+    }, []);
+    const handleCompositionEnd = hooks.useCallback((event) => {
+        isComposing.current = false;
+        // On some browsers, compositionend event is fired before the final input event,
+        // while it's the other way around on other browsers. Just call handleInput here
+        // anyway since handleInput will compare the value before actually calling it.
+        // When all browsers support the input event's isComposing property, we can use that.
+        // https://w3c.github.io/uievents/#dom-inputevent-iscomposing
+        handleInput(event);
+    }, []);
+    const handleInput = hooks.useCallback((event) => {
+        // In android device we need to update input value even for composition events
+        // See JET-39086 for more details.
+        if (isComposing.current && clientHints.getClientHints().platform !== 'android')
+            return;
+        const newValue = event.target.value;
+        if (value === newValue)
+            return;
+        onInput === null || onInput === void 0 ? void 0 : onInput({ previousValue: value, value: newValue });
+        // preactjs/preact #1899 - https://github.com/preactjs/preact/issues/1899
+        // Preact does not force the native input to be controlled, so we need to
+        // trigger a rerender in order to keep it fully controlled.
+        // Force a rerender here, so if the value was not pushed back, the input
+        // will be reset to the old value mimicking a controlled input.
+        // One minor issue here is that the cursor position will also be reverted
+        // back to the end due to the forced value update. But this behavior should
+        // be fine as it happens in our oj-input-text as well.
+        forceUpdate(null);
+    }, [value, onInput]);
+    return {
+        // With preact/compat, we will not have an onChange event.
+        // "If you're using preact/compat, most onChange events are internally converted to onInput
+        // to emulate React's behavior. This is one of the tricks we use to ensure maximum
+        // compatibility with the React ecosystem."
+        // Since we need the onChange event, we will be simulating this to match the native event
+        // as best as we can. To do this, we will be capturing `blur` event and Enter `keydown` event.
+        // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event
+        onBlur: handleChange,
+        onKeyDown: handleKeyDown,
+        // Since, preact does not support onCompositionStart and onCompositionEnd events
+        // we need to use all lowercase event name to use the native DOM events. Also,
+        // currently we do not have any need for the event object in these two handlers
+        // so ignored the arguments here.
+        oncompositionstart: handleCompositionStart,
+        oncompositionend: handleCompositionEnd,
+        onInput: handleInput
+    };
+}
+
+exports.useTextFieldInputHandlers = useTextFieldInputHandlers;
+/*  */
+//# sourceMappingURL=UNSAFE_useTextFieldInputHandlers.js.map

package/cjs/hooks/UNSAFE_useTextFieldInputHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useTextFieldInputHandlers.js","sources":["../../../src/hooks/UNSAFE_useTextFieldInputHandlers/useTextFieldInputHandlers.ts"],"sourcesContent":["import { useCallback, useReducer, useRef } from 'preact/hooks';\nimport { getClientHints } from '../../utils/PRIVATE_clientHints';\nimport { ValueUpdateDetail } from '../../utils/UNSAFE_valueUpdateDetail';\n\ntype TextFieldInputProps = {\n  currentCommitValue?: string;\n  value?: string;\n  onInput?: (detail: ValueUpdateDetail<string>) => void;\n  onCommit?: (detail: ValueUpdateDetail<string>) => void;\n  onKeyDown?: (event: KeyboardEvent) => void;\n};\n\nexport function useTextFieldInputHandlers({\n  currentCommitValue,\n  value,\n  onInput,\n  onCommit,\n  onKeyDown\n}: TextFieldInputProps) {\n  const isComposing = useRef(false);\n\n  // preactjs/preact #1899 - https://github.com/preactjs/preact/issues/1899\n  // Preact does not force the native input to be controlled, so we need to\n  // trigger a rerender in order to keep it fully controlled.\n  // Force update hack is from https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate\n  const [, forceUpdate] = useReducer((x) => x + 1, 0);\n\n  // TODO: Currently, this assumes that the input field is a text field\n  // so that the change event can be simulated by capturing blur and enter keydown\n  // event. We might have to make this generic to handle other input types\n  // as well like radio, select, checkbox.\n  const handleChange = useCallback(\n    (event: Event) => {\n      const currentValue = (event.target as HTMLInputElement).value;\n      // When do we *not* want to call onCommit?\n      // When the input's value\n      // is the same as the currentCommitValue (like if the user hits Enter over and over,\n      // or if the user focuses and blurs over and over).\n      // Or when the component's value is programmatically changed.\n      // (currentCommitValue is updated whenever we commit or get a programmatic change.\n      // See component code and useCurrentValueReducer hook)\n\n      // We only need to trigger an onCommit for user interacted changes, not programmatic changes\n      if (currentCommitValue !== currentValue) {\n        onCommit?.({ previousValue: currentCommitValue, value: currentValue });\n      }\n    },\n    [onCommit, currentCommitValue]\n  );\n  const handleKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      onKeyDown?.(event);\n\n      if (event.key === 'Enter') {\n        handleChange(event);\n      }\n    },\n    [handleChange, onKeyDown]\n  );\n  const handleCompositionStart = useCallback(() => {\n    isComposing.current = true;\n  }, []);\n  const handleCompositionEnd = useCallback((event: Event) => {\n    isComposing.current = false;\n    // On some browsers, compositionend event is fired before the final input event,\n    // while it's the other way around on other browsers. Just call handleInput here\n    // anyway since handleInput will compare the value before actually calling it.\n    // When all browsers support the input event's isComposing property, we can use that.\n    // https://w3c.github.io/uievents/#dom-inputevent-iscomposing\n    handleInput(event);\n  }, []);\n  const handleInput = useCallback(\n    (event: Event) => {\n      // In android device we need to update input value even for composition events\n      // See JET-39086 for more details.\n      if (isComposing.current && getClientHints().platform !== 'android') return;\n\n      const newValue = (event.target as HTMLInputElement).value;\n      if (value === newValue) return;\n\n      onInput?.({ previousValue: value, value: newValue });\n\n      // preactjs/preact #1899 - https://github.com/preactjs/preact/issues/1899\n      // Preact does not force the native input to be controlled, so we need to\n      // trigger a rerender in order to keep it fully controlled.\n      // Force a rerender here, so if the value was not pushed back, the input\n      // will be reset to the old value mimicking a controlled input.\n      // One minor issue here is that the cursor position will also be reverted\n      // back to the end due to the forced value update. But this behavior should\n      // be fine as it happens in our oj-input-text as well.\n      forceUpdate(null);\n    },\n    [value, onInput]\n  );\n\n  return {\n    // With preact/compat, we will not have an onChange event.\n    // \"If you're using preact/compat, most onChange events are internally converted to onInput\n    // to emulate React's behavior. This is one of the tricks we use to ensure maximum\n    // compatibility with the React ecosystem.\"\n    // Since we need the onChange event, we will be simulating this to match the native event\n    // as best as we can. To do this, we will be capturing `blur` event and Enter `keydown` event.\n    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/change_event\n    onBlur: handleChange,\n    onKeyDown: handleKeyDown,\n    // Since, preact does not support onCompositionStart and onCompositionEnd events\n    // we need to use all lowercase event name to use the native DOM events. Also,\n    // currently we do not have any need for the event object in these two handlers\n    // so ignored the arguments here.\n    oncompositionstart: handleCompositionStart,\n    oncompositionend: handleCompositionEnd,\n    onInput: handleInput\n  };\n}\n"],"names":["useRef","useReducer","useCallback","getClientHints"],"mappings":";;;;;;;;;AAYgB,SAAA,yBAAyB,CAAC,EACxC,kBAAkB,EAClB,KAAK,EACL,OAAO,EACP,QAAQ,EACR,SAAS,EACW,EAAA;AACpB,IAAA,MAAM,WAAW,GAAGA,YAAM,CAAC,KAAK,CAAC,CAAC;;;;;AAMlC,IAAA,MAAM,GAAG,WAAW,CAAC,GAAGC,gBAAU,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;;;;;AAMpD,IAAA,MAAM,YAAY,GAAGC,iBAAW,CAC9B,CAAC,KAAY,KAAI;AACf,QAAA,MAAM,YAAY,GAAI,KAAK,CAAC,MAA2B,CAAC,KAAK,CAAC;;;;;;;;;QAU9D,IAAI,kBAAkB,KAAK,YAAY,EAAE;AACvC,YAAA,QAAQ,KAAR,IAAA,IAAA,QAAQ,KAAR,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,QAAQ,CAAG,EAAE,aAAa,EAAE,kBAAkB,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;AACxE,SAAA;AACH,KAAC,EACD,CAAC,QAAQ,EAAE,kBAAkB,CAAC,CAC/B,CAAC;AACF,IAAA,MAAM,aAAa,GAAGA,iBAAW,CAC/B,CAAC,KAAoB,KAAI;AACvB,QAAA,SAAS,aAAT,SAAS,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAT,SAAS,CAAG,KAAK,CAAC,CAAC;AAEnB,QAAA,IAAI,KAAK,CAAC,GAAG,KAAK,OAAO,EAAE;YACzB,YAAY,CAAC,KAAK,CAAC,CAAC;AACrB,SAAA;AACH,KAAC,EACD,CAAC,YAAY,EAAE,SAAS,CAAC,CAC1B,CAAC;AACF,IAAA,MAAM,sBAAsB,GAAGA,iBAAW,CAAC,MAAK;AAC9C,QAAA,WAAW,CAAC,OAAO,GAAG,IAAI,CAAC;KAC5B,EAAE,EAAE,CAAC,CAAC;AACP,IAAA,MAAM,oBAAoB,GAAGA,iBAAW,CAAC,CAAC,KAAY,KAAI;AACxD,QAAA,WAAW,CAAC,OAAO,GAAG,KAAK,CAAC;;;;;;QAM5B,WAAW,CAAC,KAAK,CAAC,CAAC;KACpB,EAAE,EAAE,CAAC,CAAC;AACP,IAAA,MAAM,WAAW,GAAGA,iBAAW,CAC7B,CAAC,KAAY,KAAI;;;QAGf,IAAI,WAAW,CAAC,OAAO,IAAIC,0BAAc,EAAE,CAAC,QAAQ,KAAK,SAAS;YAAE,OAAO;AAE3E,QAAA,MAAM,QAAQ,GAAI,KAAK,CAAC,MAA2B,CAAC,KAAK,CAAC;QAC1D,IAAI,KAAK,KAAK,QAAQ;YAAE,OAAO;AAE/B,QAAA,OAAO,KAAP,IAAA,IAAA,OAAO,KAAP,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,OAAO,CAAG,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;;;;;;;;;QAUrD,WAAW,CAAC,IAAI,CAAC,CAAC;AACpB,KAAC,EACD,CAAC,KAAK,EAAE,OAAO,CAAC,CACjB,CAAC;IAEF,OAAO;;;;;;;;AAQL,QAAA,MAAM,EAAE,YAAY;AACpB,QAAA,SAAS,EAAE,aAAa;;;;;AAKxB,QAAA,kBAAkB,EAAE,sBAAsB;AAC1C,QAAA,gBAAgB,EAAE,oBAAoB;AACtC,QAAA,OAAO,EAAE,WAAW;KACrB,CAAC;AACJ;;;;;;;"}

package/cjs/hooks/UNSAFE_useTheme.js

@@ -0,0 +1,34 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+var UNSAFE_Environment = require('../UNSAFE_Environment.js');
+require('preact');
+require('preact/jsx-runtime');
+require('../UNSAFE_Layer.js');
+require('preact/compat');
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+function useTheme() {
+    return hooks.useContext(UNSAFE_Environment.EnvironmentContext).theme;
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+
+exports.useTheme = useTheme;
+/*  */
+//# sourceMappingURL=UNSAFE_useTheme.js.map

package/cjs/hooks/UNSAFE_useTheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useTheme.js","sources":["../../../src/hooks/UNSAFE_useTheme/useTheme.ts","../../../src/hooks/UNSAFE_useTheme/index.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport { useContext } from 'preact/hooks';\nimport { EnvironmentContext } from '../../UNSAFE_Environment';\n\nexport function useTheme() {\n  return useContext(EnvironmentContext).theme;\n}\n","/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nexport { useTheme } from './useTheme';\n"],"names":["useContext","EnvironmentContext"],"mappings":";;;;;;;;;;;;AAAA;;;;;;AAMG;SAIa,QAAQ,GAAA;AACtB,IAAA,OAAOA,gBAAU,CAACC,qCAAkB,CAAC,CAAC,KAAK,CAAC;AAC9C;;ACZA;;;;;;AAMG;;;;;;;"}

package/cjs/hooks/UNSAFE_useTimer.js

@@ -0,0 +1,63 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Hook for a timer.
+ * @param isStarted Specifies whether the timer should be started: true to start it, false to stop
+ * it.
+ * @param delay Specifies the delay after which the timer should expire.
+ * @returns True if the timer expires, false if it was stopped before that.
+ *
+ */
+function useTimer({ isStarted, delay = 0 }) {
+    const timeoutId = hooks.useRef(null);
+    const [isExpired, setExpired] = hooks.useState(false);
+    hooks.useEffect(() => {
+        if (!isStarted) {
+            // if not started, clear the current timeout
+            if (timeoutId.current) {
+                clearTimeout(timeoutId.current);
+                timeoutId.current = null;
+            }
+            setExpired(false);
+        }
+        else {
+            // if started, only create a new timeout if we don't already have one
+            if (!timeoutId.current) {
+                timeoutId.current = setTimeout(() => {
+                    setExpired(true);
+                }, delay);
+            }
+        }
+        return () => {
+            if (timeoutId.current) {
+                clearTimeout(timeoutId.current);
+                timeoutId.current = null;
+            }
+        };
+    }, [isStarted, delay]);
+    return isExpired;
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+
+exports.useTimer = useTimer;
+/*  */
+//# sourceMappingURL=UNSAFE_useTimer.js.map

package/cjs/hooks/UNSAFE_useTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useTimer.js","sources":["../../../src/hooks/UNSAFE_useTimer/useTimer.ts","../../../src/hooks/UNSAFE_useTimer/index.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { useEffect, useRef, useState } from 'preact/hooks';\n\ntype Props = {\n  isStarted: boolean;\n  delay?: number;\n};\n\n/**\n * Hook for a timer.\n * @param isStarted Specifies whether the timer should be started: true to start it, false to stop\n * it.\n * @param delay Specifies the delay after which the timer should expire.\n * @returns True if the timer expires, false if it was stopped before that.\n *\n */\nexport function useTimer({ isStarted, delay = 0 }: Props): boolean {\n  const timeoutId = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const [isExpired, setExpired] = useState(false);\n  useEffect(() => {\n    if (!isStarted) {\n      // if not started, clear the current timeout\n      if (timeoutId.current) {\n        clearTimeout(timeoutId.current);\n        timeoutId.current = null;\n      }\n      setExpired(false);\n    } else {\n      // if started, only create a new timeout if we don't already have one\n      if (!timeoutId.current) {\n        timeoutId.current = setTimeout(() => {\n          setExpired(true);\n        }, delay);\n      }\n    }\n    return () => {\n      if (timeoutId.current) {\n        clearTimeout(timeoutId.current);\n        timeoutId.current = null;\n      }\n    };\n  }, [isStarted, delay]);\n\n  return isExpired;\n}\n","/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nexport { useTimer } from './useTimer';\n"],"names":["useRef","useState","useEffect"],"mappings":";;;;;;;AAAA;;;;;;AAMG;AASH;;;;;;;AAOG;AACG,SAAU,QAAQ,CAAC,EAAE,SAAS,EAAE,KAAK,GAAG,CAAC,EAAS,EAAA;AACtD,IAAA,MAAM,SAAS,GAAGA,YAAM,CAAuC,IAAI,CAAC,CAAC;IACrE,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,GAAGC,cAAQ,CAAC,KAAK,CAAC,CAAC;IAChDC,eAAS,CAAC,MAAK;QACb,IAAI,CAAC,SAAS,EAAE;;YAEd,IAAI,SAAS,CAAC,OAAO,EAAE;AACrB,gBAAA,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAChC,gBAAA,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;AAC1B,aAAA;YACD,UAAU,CAAC,KAAK,CAAC,CAAC;AACnB,SAAA;AAAM,aAAA;;AAEL,YAAA,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;AACtB,gBAAA,SAAS,CAAC,OAAO,GAAG,UAAU,CAAC,MAAK;oBAClC,UAAU,CAAC,IAAI,CAAC,CAAC;iBAClB,EAAE,KAAK,CAAC,CAAC;AACX,aAAA;AACF,SAAA;AACD,QAAA,OAAO,MAAK;YACV,IAAI,SAAS,CAAC,OAAO,EAAE;AACrB,gBAAA,YAAY,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AAChC,gBAAA,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;AAC1B,aAAA;AACH,SAAC,CAAC;AACJ,KAAC,EAAE,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;AAEvB,IAAA,OAAO,SAAS,CAAC;AACnB;;ACnDA;;;;;;AAMG;;;;;;;"}

package/cjs/hooks/UNSAFE_useToggle.js

@@ -0,0 +1,36 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+
+/**
+ * useToggle is a state toggle hook
+ *
+ * @param defaultValue
+ * @returns
+ */
+function useToggle(defaultValue = false) {
+    const [bool, setBool] = hooks.useState(defaultValue);
+    const toggleHandlers = hooks.useMemo(() => {
+        return {
+            toggle: () => setBool((x) => !x),
+            setTrue: () => setBool(true),
+            setFalse: () => setBool(false)
+        };
+    }, []);
+    return Object.assign({ bool }, toggleHandlers);
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+
+exports.useToggle = useToggle;
+/*  */
+//# sourceMappingURL=UNSAFE_useToggle.js.map

package/cjs/hooks/UNSAFE_useToggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useToggle.js","sources":["../../../src/hooks/UNSAFE_useToggle/useToggle.ts","../../../src/hooks/UNSAFE_useToggle/index.ts"],"sourcesContent":["import { useState, useMemo } from 'preact/hooks';\n\n/**\n * useToggle is a state toggle hook\n *\n * @param defaultValue\n * @returns\n */\n\nexport function useToggle(defaultValue = false) {\n  const [bool, setBool] = useState(defaultValue);\n  const toggleHandlers = useMemo(() => {\n    return {\n      toggle: () => setBool((x) => !x),\n      setTrue: () => setBool(true),\n      setFalse: () => setBool(false)\n    };\n  }, []);\n\n  return {\n    bool,\n    ...toggleHandlers\n  };\n}\n","/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nexport { useToggle } from './useToggle';\n"],"names":["useState","useMemo"],"mappings":";;;;;;;AAEA;;;;;AAKG;AAEa,SAAA,SAAS,CAAC,YAAY,GAAG,KAAK,EAAA;IAC5C,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAGA,cAAQ,CAAC,YAAY,CAAC,CAAC;AAC/C,IAAA,MAAM,cAAc,GAAGC,aAAO,CAAC,MAAK;QAClC,OAAO;AACL,YAAA,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;AAChC,YAAA,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;AAC5B,YAAA,QAAQ,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC;SAC/B,CAAC;KACH,EAAE,EAAE,CAAC,CAAC;IAEP,OACE,MAAA,CAAA,MAAA,CAAA,EAAA,IAAI,EACD,EAAA,cAAc,CACjB,CAAA;AACJ;;ACvBA;;;;;;AAMG;;;;;;;"}

package/cjs/hooks/UNSAFE_useTooltip.js

@@ -0,0 +1,376 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+var jsxRuntime = require('preact/jsx-runtime');
+var hooks_UNSAFE_useId = require('./UNSAFE_useId.js');
+require('../UNSAFE_Floating.js');
+var UNSAFE_Layer = require('../UNSAFE_Layer.js');
+var hooks_UNSAFE_useHover = require('./UNSAFE_useHover.js');
+var hooks_UNSAFE_useFocus = require('./UNSAFE_useFocus.js');
+var hooks_UNSAFE_useTouch = require('./UNSAFE_useTouch.js');
+var utils_UNSAFE_mergeProps = require('../utils/UNSAFE_mergeProps.js');
+var utils_UNSAFE_arrayUtils = require('../utils/UNSAFE_arrayUtils.js');
+var tslib_es6 = require('../tslib.es6-d7adde1f.js');
+require('./UNSAFE_useAnimation.js');
+require("identity-obj-proxy");
+require('../utils/UNSAFE_classNames.js');
+var useAnimation = require('../useAnimation-9e794d84.js');
+var classNames = require('../classNames-825d80d7.js');
+var Floating = require('../Floating-3eb600a1.js');
+require('preact/compat');
+require('preact');
+require('./UNSAFE_useToggle.js');
+require('../index-94b1ff28.js');
+require('./UNSAFE_useUser.js');
+require('../UNSAFE_Environment.js');
+require('../utils/PRIVATE_floatingUtils.js');
+require('../utils/PRIVATE_refUtils.js');
+require('./UNSAFE_useOutsideClick.js');
+
+const styles = {
+  wrapper: "_1071n2l",
+  inner: "c3xikh",
+  base: "_1ntmaqk",
+  datatip: "_16rlniq"
+};
+const TooltipContent = _a => {
+  var {
+    children,
+    isOpen,
+    isDatatip,
+    onTransitionEnd
+  } = _a,
+      props = tslib_es6.__rest(_a, ["children", "isOpen", "isDatatip", "onTransitionEnd"]);
+
+  const uniqueID = hooks_UNSAFE_useId.useId();
+  const wrapperRef = hooks.useRef(null);
+  const popoverRef = hooks.useRef(null);
+  const {
+    nodeRef
+  } = useAnimation.useAnimation(isOpen ? 'mounted' : 'unmounted', {
+    animationStates: {
+      mounted: _node => {
+        const childNode = _node.firstChild;
+        return {
+          from: {
+            maxHeight: '0',
+            opacity: '0%'
+          },
+          to: {
+            maxHeight: `${childNode === null || childNode === void 0 ? void 0 : childNode.offsetHeight}px`,
+            opacity: isDatatip ? '100%' : '95%'
+          },
+          options: {
+            duration: isDatatip ? 1 : 100,
+            easing: [0.0, 0.0, 0.2, 1]
+          }
+        };
+      },
+      unmounted: _node => {
+        return {
+          from: {
+            opacity: isDatatip ? '100%' : '95%'
+          },
+          to: {
+            maxHeight: '0',
+            opacity: '0%'
+          },
+          options: {
+            duration: isDatatip ? 1 : 100,
+            easing: [0.0, 0.0, 0.2, 1]
+          }
+        };
+      }
+    },
+    isAnimatedOnMount: true,
+    onAnimationEnd: () => onTransitionEnd === null || onTransitionEnd === void 0 ? void 0 : onTransitionEnd()
+  }); // Set up initial wrapper height so Tooltip can animate from the bottom to the top
+
+  hooks.useEffect(() => {
+    var _a, _b;
+
+    if (wrapperRef.current && ((_a = popoverRef.current) === null || _a === void 0 ? void 0 : _a.offsetHeight)) {
+      wrapperRef.current.style.height = `${(_b = popoverRef.current) === null || _b === void 0 ? void 0 : _b.offsetHeight}px`;
+    }
+  }, []);
+  return jsxRuntime.jsx("div", Object.assign({
+    ref: wrapperRef,
+    id: uniqueID,
+    role: "tooltip",
+    class: styles.wrapper
+  }, {
+    children: jsxRuntime.jsx("div", Object.assign({
+      ref: nodeRef,
+      class: classNames.classNames([styles.inner])
+    }, props, {
+      children: jsxRuntime.jsx("div", Object.assign({
+        ref: popoverRef,
+        class: classNames.classNames([styles.base, isDatatip ? styles.datatip : ''])
+      }, {
+        children: children
+      }))
+    }))
+  }));
+};
+
+const positions = utils_UNSAFE_arrayUtils.stringLiteralArray([
+    'start',
+    'top-start',
+    'top',
+    'top-end',
+    'end',
+    'bottom-end',
+    'bottom',
+    'bottom-start'
+]);
+const positionToPlacement = (position) => {
+    let placement = 'bottom';
+    switch (position) {
+        case 'top':
+        case 'end':
+        case 'bottom':
+        case 'start':
+            placement = position;
+            break;
+        case 'top-end':
+            placement = 'top-end-corner';
+            break;
+        case 'bottom-end':
+            placement = 'bottom-end-corner';
+            break;
+        case 'bottom-start':
+            placement = 'bottom-start-corner';
+            break;
+        case 'top-start':
+            placement = 'top-start-corner';
+            break;
+    }
+    return placement;
+};
+const anchorTos = utils_UNSAFE_arrayUtils.stringLiteralArray(['element', 'pointer']);
+const useTooltipControlled = ({ text, isOpen = false, variant = 'tooltip', position = 'bottom', isDisabled = false, anchor = { x: 'element', y: 'element' }, offset = { mainAxis: 0, crossAxis: 0 }, onToggle }) => {
+    const disabled = isDisabled || !text;
+    const isInitialRenderState = hooks.useRef(true);
+    const [state, setState] = hooks.useState(!disabled && isOpen ? 'mounting' : 'unmounted');
+    const [needsUpdate, setNeedsUpdate] = hooks.useState(false);
+    setNeedsUpdate(false);
+    const isDatatip = variant === 'datatip';
+    const isInitialRenderTrigger = hooks.useRef(true);
+    const { hoverProps, isHover } = hooks_UNSAFE_useHover.useHover({ isDisabled });
+    const { touchProps, isTouch } = hooks_UNSAFE_useTouch.useTouch({ isDisabled }); // TODO replace by useLongPress actionhook
+    // we only care about keyboard focus, don't enable useFocus hook if isHover or isTouch are active
+    const { focusProps, isFocus } = hooks_UNSAFE_useFocus.useFocus({ isDisabled: isHover || isTouch });
+    const { hoverProps: popoverHoverProps, isHover: popoverIsHover } = hooks_UNSAFE_useHover.useHover({ isDisabled });
+    const isPointer = anchor.x === 'pointer' || anchor.y === 'pointer';
+    const uniqueID = hooks_UNSAFE_useId.useId();
+    const targetRef = hooks.useRef(null);
+    const coordsRef = hooks.useRef({ x: 0, y: 0 });
+    // if anchor is set to pointer and target does not have keyboard focus, use coords
+    const usedRef = isPointer && !isFocus ? coordsRef : targetRef;
+    const delay = isDatatip ? 0 : 250;
+    const toggleTimeoutRef = hooks.useRef(null);
+    const updateTimeoutRef = hooks.useRef(null);
+    const toggleTimeoutClear = () => {
+        if (toggleTimeoutRef.current) {
+            clearTimeout(toggleTimeoutRef.current);
+        }
+    };
+    const updateTimeoutClear = () => {
+        if (updateTimeoutRef.current) {
+            clearTimeout(updateTimeoutRef.current);
+        }
+    };
+    const updateState = hooks.useCallback((open) => {
+        if (open) {
+            // At least one toggle event is set to true
+            switch (state) {
+                case 'unmounting':
+                case 'unmounted':
+                    setState('mountPending'); // Set mount pending state if tooltip is unmounted or in unmounting transition
+                    break;
+                case 'unmountPending':
+                    toggleTimeoutClear();
+                    setState('mounted'); // Clear timers immediately and keep the tooltip mounted
+                    break;
+            }
+        }
+        else {
+            // No toggle events are set to true
+            switch (state) {
+                case 'mounting':
+                case 'mounted':
+                    setState('unmountPending'); // Set unmount pending state if tooltip is mounted or in mounting transition
+                    break;
+                case 'mountPending':
+                    toggleTimeoutClear();
+                    setState('unmounted'); // Unmount tooltip immediately if mounting is pending
+                    break;
+            }
+        }
+    }, [state]);
+    hooks.useEffect(() => {
+        if (isInitialRenderState.current) {
+            // On onitial render do not trigger rerender
+            isInitialRenderState.current = false;
+            return;
+        }
+        setState(isOpen ? 'mounting' : 'unmounting');
+    }, [isOpen]);
+    hooks.useEffect(() => {
+        if (isInitialRenderTrigger.current) {
+            // On onitial render do not trigger rerender
+            isInitialRenderTrigger.current = false;
+            return;
+        }
+        // When pointer is used, handleMouseMove method is responsible for state updates
+        // until the tooltip is mounted
+        if (isPointer && isHover && state === 'unmounted') {
+            return;
+        }
+        updateTimeoutClear();
+        // isHover and popoverIsHover may change rapidly as the pointer moves between the target
+        // and tooltip. Need to wait for changes to settle to avoid flashing.
+        updateTimeoutRef.current = setTimeout(() => {
+            updateState(isHover || isFocus || popoverIsHover || isTouch);
+        }, 20);
+    }, [isHover, isFocus, popoverIsHover, isTouch, isPointer, state, updateState]);
+    /*
+     In some cases, several state transitions can occur at once. Due to the asynchronous nature
+     of hooks, this can create a race condition. For example, when the cursor leaves the target
+     element and immediately moves to the tooltip itself, the following sequence occurs:
+     1. isHover is set to false and a new render is triggered
+     2. The state is set to 'unmountPending' and a new render is triggered
+     3. Pending timeout is set
+     4. isHover is set to true and a new render is triggered
+     5. Pending timeout is cleared
+     However, sometimes the timeout is cleared before it is set. The useLayoutEffect prevents this
+     race condition by always scheduling the timeout synchronously.
+    */
+    hooks.useLayoutEffect(() => {
+        if (state === 'mountPending' || state === 'unmountPending') {
+            toggleTimeoutRef.current = setTimeout(() => onToggle === null || onToggle === void 0 ? void 0 : onToggle({ value: state === 'mountPending' }), delay);
+        }
+    }, [state, delay, onToggle]);
+    const handleMouseMove = (event) => {
+        var _a;
+        // we only want track mouse move while the state is 'unmounted' or when moving a 'mounted' datatip
+        if (state !== 'unmounted' && !(variant === 'datatip' && state === 'mounted')) {
+            return;
+        }
+        const targetRect = (_a = targetRef === null || targetRef === void 0 ? void 0 : targetRef.current) === null || _a === void 0 ? void 0 : _a.getBoundingClientRect();
+        // Tooltip maintains static offset from left side of window
+        const distanceX = document.body.scrollLeft + ((targetRect === null || targetRect === void 0 ? void 0 : targetRect.left) || 0) + ((targetRect === null || targetRect === void 0 ? void 0 : targetRect.width) || 0);
+        // Tooltip maintains static offset from top side of the window
+        const distanceY = document.body.scrollTop + ((targetRect === null || targetRect === void 0 ? void 0 : targetRect.top) || 0) + ((targetRect === null || targetRect === void 0 ? void 0 : targetRect.height) || 0);
+        // Display tooltip at the mouse position if both anchors are set to pointer
+        const x = anchor.x === 'pointer' ? event.clientX : distanceX;
+        const y = anchor.y === 'pointer' ? event.clientY : distanceY;
+        if (state === 'mounted') {
+            coordsRef.current = { x, y };
+            if (needsUpdate !== true)
+                setNeedsUpdate(true);
+        }
+        else if (state === 'unmounted') {
+            toggleTimeoutClear();
+            toggleTimeoutRef.current = setTimeout(() => {
+                if (state === 'unmounted') {
+                    coordsRef.current = { x, y };
+                    onToggle === null || onToggle === void 0 ? void 0 : onToggle({ value: true });
+                }
+            }, delay);
+        }
+    };
+    const focusInitProps = {
+        onFocus: (event) => {
+            if (event.eventPhase === Event.AT_TARGET ||
+                (event.eventPhase === Event.BUBBLING_PHASE && isDatatip)) {
+                targetRef.current = event.target;
+            }
+        }
+    };
+    let actionableProps;
+    if (disabled) {
+        actionableProps = utils_UNSAFE_mergeProps.mergeProps(focusProps, focusInitProps);
+    }
+    else {
+        const anchorInitProps = Object.assign({ 'aria-describedby': uniqueID, onMouseEnter: (event) => {
+                if (event.eventPhase === Event.AT_TARGET ||
+                    (event.eventPhase === Event.BUBBLING_PHASE && isDatatip)) {
+                    targetRef.current = event.target;
+                }
+            } }, (isPointer && {
+            onMouseLeave: () => {
+                if (state === 'mounting') {
+                    return;
+                }
+                toggleTimeoutClear();
+            },
+            onMouseMove: (event) => {
+                if (event.eventPhase === Event.AT_TARGET ||
+                    (event.eventPhase === Event.BUBBLING_PHASE && isDatatip)) {
+                    handleMouseMove(event);
+                }
+            }
+        }));
+        actionableProps = utils_UNSAFE_mergeProps.mergeProps(hoverProps, focusProps, touchProps, focusInitProps, anchorInitProps);
+    }
+    // No need to process tooltip if disabled or no text is provided
+    // Include actionableProps to detect mouseenter in components
+    // hovered state won't update unless actionableProps are already present in the component when mouse enters
+    if (disabled) {
+        toggleTimeoutClear();
+        return {
+            tooltipContent: null,
+            tooltipProps: actionableProps
+        };
+    }
+    const placement = positionToPlacement(position);
+    const handleTransitionEnd = () => {
+        if (state === 'mounting') {
+            setState('mounted');
+        }
+        if (state === 'unmounting') {
+            setState('unmounted');
+        }
+    };
+    const renderContent = (jsxRuntime.jsx(UNSAFE_Layer.Layer, Object.assign({ logicalParentRef: targetRef }, { children: jsxRuntime.jsx(Floating.Floating, Object.assign({ anchorRef: usedRef, placement: placement, offsetValue: offset }, { children: jsxRuntime.jsx(TooltipContent, Object.assign({ isOpen: ['mounting', 'mounted', 'unmountPending'].includes(state) }, popoverHoverProps, { isDatatip: isDatatip, onTransitionEnd: handleTransitionEnd }, { children: text })) })) })));
+    return {
+        tooltipContent: !['unmounted', 'mountPending'].includes(state) && renderContent,
+        tooltipProps: actionableProps
+    };
+};
+
+const useTooltip = ({ text, position = 'bottom', isDisabled = false, anchor = { x: 'element', y: 'element' }, offset = { mainAxis: 0, crossAxis: 0 }, variant = 'tooltip' }) => {
+    const [isOpen, setIsOpen] = hooks.useState(false);
+    const disabled = isDisabled || !text;
+    const { tooltipContent, tooltipProps } = useTooltipControlled({
+        text,
+        isOpen,
+        position,
+        isDisabled: disabled,
+        offset,
+        anchor,
+        variant,
+        onToggle: ({ value }) => setIsOpen(value)
+    });
+    return {
+        tooltipContent,
+        tooltipProps
+    };
+};
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+
+exports.useTooltip = useTooltip;
+exports.useTooltipControlled = useTooltipControlled;
+/*  */
+//# sourceMappingURL=UNSAFE_useTooltip.js.map