@oracle/oraclejet-preact 14.0.0

package/es/hooks/UNSAFE_useClearIcon.js

@@ -0,0 +1,20 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useCallback, useEffect } from 'preact/hooks';
+import { useToggle } from './UNSAFE_useToggle.js';
+
+/**
+ * A custom hook that handles showing/hiding clear icon
+ */
+function useClearIcon({ clearIcon, display, hasValue, isEnabled = true, isFocused = false, isHover = false }) {
+    const shouldRenderClearIcon = useCallback(() => isEnabled &&
+        (display === 'always' || (display === 'conditionally' && hasValue && (isFocused || isHover))), [display, hasValue, isEnabled, isFocused, isHover]);
+    const { bool, setFalse, setTrue } = useToggle(shouldRenderClearIcon());
+    useEffect(() => {
+        shouldRenderClearIcon() ? setTrue() : setFalse();
+    }, [shouldRenderClearIcon]);
+    return bool ? clearIcon : null;
+}
+
+export { useClearIcon };
+/*  */
+//# sourceMappingURL=UNSAFE_useClearIcon.js.map

package/es/hooks/UNSAFE_useClearIcon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useClearIcon.js","sources":["../../../src/hooks/UNSAFE_useClearIcon/useClearIcon.ts"],"sourcesContent":["import { ComponentChildren } from 'preact';\nimport { useEffect, useCallback } from 'preact/hooks';\nimport { useToggle } from '../UNSAFE_useToggle';\n\nexport type UseClearIconProps = {\n  clearIcon?: ComponentChildren;\n  display?: 'always' | 'conditionally' | 'never';\n  hasValue?: boolean;\n  isEnabled?: boolean;\n  isFocused?: boolean;\n  isHover?: boolean;\n};\n\n/**\n * A custom hook that handles showing/hiding clear icon\n */\nexport function useClearIcon({\n  clearIcon,\n  display,\n  hasValue,\n  isEnabled = true,\n  isFocused = false,\n  isHover = false\n}: UseClearIconProps) {\n  const shouldRenderClearIcon = useCallback(\n    () =>\n      isEnabled &&\n      (display === 'always' || (display === 'conditionally' && hasValue && (isFocused || isHover))),\n    [display, hasValue, isEnabled, isFocused, isHover]\n  );\n  const { bool, setFalse, setTrue } = useToggle(shouldRenderClearIcon());\n\n  useEffect(() => {\n    shouldRenderClearIcon() ? setTrue() : setFalse();\n  }, [shouldRenderClearIcon]);\n\n  return bool ? clearIcon : null;\n}\n"],"names":[],"mappings":";;;;AAaA;;AAEG;AACG,SAAU,YAAY,CAAC,EAC3B,SAAS,EACT,OAAO,EACP,QAAQ,EACR,SAAS,GAAG,IAAI,EAChB,SAAS,GAAG,KAAK,EACjB,OAAO,GAAG,KAAK,EACG,EAAA;AAClB,IAAA,MAAM,qBAAqB,GAAG,WAAW,CACvC,MACE,SAAS;AACT,SAAC,OAAO,KAAK,QAAQ,KAAK,OAAO,KAAK,eAAe,IAAI,QAAQ,KAAK,SAAS,IAAI,OAAO,CAAC,CAAC,CAAC,EAC/F,CAAC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,CAAC,CACnD,CAAC;AACF,IAAA,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAEvE,SAAS,CAAC,MAAK;QACb,qBAAqB,EAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,EAAE,CAAC;AACnD,KAAC,EAAE,CAAC,qBAAqB,CAAC,CAAC,CAAC;IAE5B,OAAO,IAAI,GAAG,SAAS,GAAG,IAAI,CAAC;AACjC;;;;;;;"}

package/es/hooks/UNSAFE_useColorScheme.js

@@ -0,0 +1,30 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useContext } from 'preact/hooks';
+import { EnvironmentContext } from '../UNSAFE_Environment.js';
+import 'preact';
+import 'preact/jsx-runtime';
+import '../UNSAFE_Layer.js';
+import '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 useColorScheme() {
+    return useContext(EnvironmentContext).colorScheme;
+}
+
+/**
+ * @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
+ */
+
+export { useColorScheme };
+/*  */
+//# sourceMappingURL=UNSAFE_useColorScheme.js.map

package/es/hooks/UNSAFE_useColorScheme.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useColorScheme.js","sources":["../../../src/hooks/UNSAFE_useColorScheme/useColorScheme.ts","../../../src/hooks/UNSAFE_useColorScheme/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 useColorScheme() {\n  return useContext(EnvironmentContext).colorScheme;\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 { useColorScheme } from './useColorScheme';\n"],"names":[],"mappings":";;;;;;;;AAAA;;;;;;AAMG;SAIa,cAAc,GAAA;AAC5B,IAAA,OAAO,UAAU,CAAC,kBAAkB,CAAC,CAAC,WAAW,CAAC;AACpD;;ACZA;;;;;;AAMG;;;;;;;"}

package/es/hooks/UNSAFE_useContainerBreakpointValues.js

@@ -0,0 +1,22 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useContainerBreakpoints } from './UNSAFE_useContainerBreakpoints.js';
+import { defaultBreakpoints } from './UNSAFE_useBreakpoints.js';
+import 'preact/hooks';
+
+/*
+ * Custom hook to allow the user to define custom values that are returned if a breakpoint is reached.
+ * The Responsive object is a set of one or more key/value pairs, with each breakpoint as a key.
+ */
+function useContainerBreakpointValues(breakpointValues, breakpoints = defaultBreakpoints) {
+    const { breakpointMatches, ref } = useContainerBreakpoints(breakpoints);
+    const result = Object.entries(breakpointValues).reduce((p, c) => {
+        const key = c[0]; // first entry in breakpoint values is the key
+        return breakpointMatches[key] ? c : p; // if current breakpoint is true, return it, else stay with previous
+    });
+    const breakpoint = result[1]; // second entry in breakpoint values is the value
+    return { breakpoint, ref };
+}
+
+export { useContainerBreakpointValues };
+/*  */
+//# sourceMappingURL=UNSAFE_useContainerBreakpointValues.js.map

package/es/hooks/UNSAFE_useContainerBreakpointValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useContainerBreakpointValues.js","sources":["../../../src/hooks/UNSAFE_useContainerBreakpointValues/useContainerBreakpointValues.ts"],"sourcesContent":["import { useContainerBreakpoints } from '../UNSAFE_useContainerBreakpoints';\nimport { defaultBreakpoints, Breakpoints } from '../UNSAFE_useBreakpoints';\n\n/*\n * This allows a user to define key/value pairs that map to each breakpoint.\n * The user's custom value is returned when the specific breakpoint is reached.\n */\ntype DefaultBreakpoints = keyof typeof defaultBreakpoints;\ntype DefaultType<T> = Record<DefaultBreakpoints, T>;\ntype Responsive<V> = Partial<DefaultType<V>>;\n\n/*\n * Custom hook to allow the user to define custom values that are returned if a breakpoint is reached.\n * The Responsive object is a set of one or more key/value pairs, with each breakpoint as a key.\n */\nexport function useContainerBreakpointValues<V>(\n  breakpointValues: Responsive<V>,\n  breakpoints: Breakpoints = defaultBreakpoints\n) {\n  const { breakpointMatches, ref } = useContainerBreakpoints(breakpoints);\n\n  const result = Object.entries(breakpointValues).reduce((p, c) => {\n    const key = c[0]; // first entry in breakpoint values is the key\n    return breakpointMatches[key] ? c : p;  // if current breakpoint is true, return it, else stay with previous\n  });\n\n  const breakpoint = result[1]; // second entry in breakpoint values is the value\n\n  return { breakpoint, ref };\n}\n"],"names":[],"mappings":";;;;;AAWA;;;AAGG;SACa,4BAA4B,CAC1C,gBAA+B,EAC/B,cAA2B,kBAAkB,EAAA;IAE7C,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,GAAG,uBAAuB,CAAC,WAAW,CAAC,CAAC;AAExE,IAAA,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;QAC9D,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AACjB,QAAA,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AACxC,KAAC,CAAC,CAAC;IAEH,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AAE7B,IAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;AAC7B;;;;;;;"}

package/es/hooks/UNSAFE_useContainerBreakpoints.js

@@ -0,0 +1,43 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useState, useRef, useMemo, useCallback } from 'preact/hooks';
+import { defaultBreakpoints } from './UNSAFE_useBreakpoints.js';
+
+/*
+ * This custom hook returns the current breakpoints based on the width of a container, which is a DOM object.
+ * The breakpoints are returned as a set of boolean values keyed to each breakpoint.
+ *
+ * TODO: Refactor to use a single ResizeObserver for better performance
+ */
+function useContainerBreakpoints(breakpoints = defaultBreakpoints) {
+    const [width, setWidth] = useState(0);
+    const observedNodeRef = useRef(null);
+    const resizeObserver = useMemo(() => new ResizeObserver((entries) => {
+        for (const entry of entries) {
+            setWidth(entry.contentRect.width);
+        }
+    }), []);
+    const ref = useCallback((node) => {
+        const observedNode = observedNodeRef.current;
+        if (node != observedNode) {
+            if (observedNode) {
+                resizeObserver.unobserve(observedNode);
+            }
+            if (node) {
+                resizeObserver.observe(node);
+            }
+            observedNodeRef.current = node;
+        }
+    }, [resizeObserver]);
+    const breakpointMatches = useMemo(() => {
+        const matches = {};
+        for (const k in breakpoints) {
+            matches[k] = width >= parseInt(breakpoints[k]);
+        }
+        return matches;
+    }, [width, breakpoints]);
+    return { breakpointMatches, ref };
+}
+
+export { useContainerBreakpoints };
+/*  */
+//# sourceMappingURL=UNSAFE_useContainerBreakpoints.js.map

package/es/hooks/UNSAFE_useContainerBreakpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useContainerBreakpoints.js","sources":["../../../src/hooks/UNSAFE_useContainerBreakpoints/useContainerBreakpoints.ts"],"sourcesContent":["import { useState, useRef, useCallback, useMemo } from 'preact/hooks';\nimport { defaultBreakpoints, Breakpoints } from '../UNSAFE_useBreakpoints';\n\n/*\n * This custom hook returns the current breakpoints based on the width of a container, which is a DOM object.\n * The breakpoints are returned as a set of boolean values keyed to each breakpoint.\n *\n * TODO: Refactor to use a single ResizeObserver for better performance\n */\nexport function useContainerBreakpoints(breakpoints: Breakpoints = defaultBreakpoints) {\n  const [width, setWidth] = useState(0);\n  const observedNodeRef = useRef<HTMLElement | null>(null);\n\n  const resizeObserver = useMemo(\n    () =>\n      new ResizeObserver((entries) => {\n        for (const entry of entries) {\n          setWidth(entry.contentRect.width);\n        }\n      }),\n    []\n  );\n\n  const ref = useCallback(\n    (node: HTMLElement) => {\n      const observedNode = observedNodeRef.current;\n\n      if (node != observedNode) {\n        if (observedNode) {\n          resizeObserver.unobserve(observedNode);\n        }\n\n        if (node) {\n          resizeObserver.observe(node);\n        }\n\n        observedNodeRef.current = node;\n      }\n    },\n    [resizeObserver]\n  );\n\n  const breakpointMatches = useMemo(() => {\n    const matches: Record<string, boolean> = {};\n    for (const k in breakpoints) {\n      matches[k] = width >= parseInt(breakpoints[k]);\n    }\n    return matches;\n  }, [width, breakpoints]);\n\n  return { breakpointMatches, ref };\n}\n"],"names":[],"mappings":";;;;AAGA;;;;;AAKG;AACa,SAAA,uBAAuB,CAAC,WAAA,GAA2B,kBAAkB,EAAA;IACnF,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AACtC,IAAA,MAAM,eAAe,GAAG,MAAM,CAAqB,IAAI,CAAC,CAAC;AAEzD,IAAA,MAAM,cAAc,GAAG,OAAO,CAC5B,MACE,IAAI,cAAc,CAAC,CAAC,OAAO,KAAI;AAC7B,QAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;AAC3B,YAAA,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AACnC,SAAA;AACH,KAAC,CAAC,EACJ,EAAE,CACH,CAAC;AAEF,IAAA,MAAM,GAAG,GAAG,WAAW,CACrB,CAAC,IAAiB,KAAI;AACpB,QAAA,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC;QAE7C,IAAI,IAAI,IAAI,YAAY,EAAE;AACxB,YAAA,IAAI,YAAY,EAAE;AAChB,gBAAA,cAAc,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;AACxC,aAAA;AAED,YAAA,IAAI,IAAI,EAAE;AACR,gBAAA,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AAC9B,aAAA;AAED,YAAA,eAAe,CAAC,OAAO,GAAG,IAAI,CAAC;AAChC,SAAA;AACH,KAAC,EACD,CAAC,cAAc,CAAC,CACjB,CAAC;AAEF,IAAA,MAAM,iBAAiB,GAAG,OAAO,CAAC,MAAK;QACrC,MAAM,OAAO,GAA4B,EAAE,CAAC;AAC5C,QAAA,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE;AAC3B,YAAA,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAChD,SAAA;AACD,QAAA,OAAO,OAAO,CAAC;AACjB,KAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;AAEzB,IAAA,OAAO,EAAE,iBAAiB,EAAE,GAAG,EAAE,CAAC;AACpC;;;;;;;"}

package/es/hooks/UNSAFE_useCurrentValueReducer.js

@@ -0,0 +1,57 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useReducer, useEffect } from 'preact/hooks';
+
+const currentValueReducer = (state, { type, payload }) => {
+    switch (type) {
+        case 'input':
+            return Object.assign(Object.assign({}, state), { currentInputValue: payload });
+        case 'commit':
+            return Object.assign(Object.assign({}, state), { currentCommitValue: payload, currentInputValue: payload });
+        default:
+            throw new Error(`Unknown action type: ${type}`);
+    }
+};
+/**
+ * This hook takes an Object with a value, and returns currentCommitValue and dispatch.
+ *
+ * Whenever you call onInput, call dispatch({ type: 'input', payload: value });
+ * For example:
+ * dispatch({ type: 'input', payload: detail.value });
+ * onInput?.(detail);
+ * And similarly whenever you call onCommit, call dispatch({ type: 'commit', payload: value });
+ *
+ * The state is used to determine if the component's value property was programmatically
+ * changed or just changed from an onInput listener to update the value back
+ * to what the user typed in which is required for a controlled component.
+ *
+ * @param param0 The props for the useCurrentValueReducer hook
+ * @returns
+ */
+function useCurrentValueReducer({ value }) {
+    const [state, dispatch] = useReducer(currentValueReducer, {
+        currentInputValue: value,
+        currentCommitValue: value
+    });
+    useEffect(() => {
+        // If the value is different than the currentInputValue, that means
+        // the value was programmatically changed. state.currentInputValue gets
+        // updated on every keystroke (onInput).
+        const programmaticallyChanged = value !== state.currentInputValue;
+        if (programmaticallyChanged) {
+            // dispatch type commit synces up the currentCommitValue and the currentInputValue.
+            // We don't want to call the user's
+            // onCommit for the case where the value is programmatically changed, so we sync the
+            // input/commit states every time onCommit is called and also here.
+            // For more details, see useTextFieldInputHandler#onChange
+            dispatch({ type: 'commit', payload: value });
+        }
+    }, [value, state.currentInputValue]);
+    return {
+        currentCommitValue: state.currentCommitValue,
+        dispatch
+    };
+}
+
+export { useCurrentValueReducer };
+/*  */
+//# sourceMappingURL=UNSAFE_useCurrentValueReducer.js.map

package/es/hooks/UNSAFE_useCurrentValueReducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useCurrentValueReducer.js","sources":["../../../src/hooks/UNSAFE_useCurrentValueReducer/useCurrentValueReducer.ts"],"sourcesContent":["import { ComponentProps } from 'preact';\nimport { useEffect, useReducer } from 'preact/hooks';\nimport { TextFieldInput } from '../../UNSAFE_TextField';\n\ntype TextFieldInputProps = ComponentProps<typeof TextFieldInput>;\n\ntype UseCurrentValueProps = {\n  value?: TextFieldInputProps['value'];\n};\n\ntype CurrentValueState = {\n  currentInputValue?: string;\n  currentCommitValue?: string;\n};\n\ntype CurrentValueDispatchAction = {\n  type: 'input' | 'commit';\n  payload?: string;\n};\n\nconst currentValueReducer = (\n  state: CurrentValueState,\n  { type, payload }: CurrentValueDispatchAction\n) => {\n  switch (type) {\n    case 'input':\n      return { ...state, currentInputValue: payload };\n    case 'commit':\n      return { ...state, currentCommitValue: payload, currentInputValue: payload };\n    default:\n      throw new Error(`Unknown action type: ${type}`);\n  }\n};\n\n/**\n * This hook takes an Object with a value, and returns currentCommitValue and dispatch.\n *\n * Whenever you call onInput, call dispatch({ type: 'input', payload: value });\n * For example:\n * dispatch({ type: 'input', payload: detail.value });\n * onInput?.(detail);\n * And similarly whenever you call onCommit, call dispatch({ type: 'commit', payload: value });\n *\n * The state is used to determine if the component's value property was programmatically\n * changed or just changed from an onInput listener to update the value back\n * to what the user typed in which is required for a controlled component.\n *\n * @param param0 The props for the useCurrentValueReducer hook\n * @returns\n */\nexport function useCurrentValueReducer({ value }: UseCurrentValueProps) {\n  const [state, dispatch] = useReducer(currentValueReducer, {\n    currentInputValue: value,\n    currentCommitValue: value\n  });\n\n  useEffect(() => {\n    // If the value is different than the currentInputValue, that means\n    // the value was programmatically changed. state.currentInputValue gets\n    // updated on every keystroke (onInput).\n    const programmaticallyChanged = value !== state.currentInputValue;\n    if (programmaticallyChanged) {\n      // dispatch type commit synces up the currentCommitValue and the currentInputValue.\n      // We don't want to call the user's\n      // onCommit for the case where the value is programmatically changed, so we sync the\n      // input/commit states every time onCommit is called and also here.\n      // For more details, see useTextFieldInputHandler#onChange\n      dispatch({ type: 'commit', payload: value });\n    }\n  }, [value, state.currentInputValue]);\n\n  return {\n    currentCommitValue: state.currentCommitValue,\n    dispatch\n  };\n}\n"],"names":[],"mappings":";;;AAoBA,MAAM,mBAAmB,GAAG,CAC1B,KAAwB,EACxB,EAAE,IAAI,EAAE,OAAO,EAA8B,KAC3C;AACF,IAAA,QAAQ,IAAI;AACV,QAAA,KAAK,OAAO;AACV,YAAA,OAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAY,KAAK,CAAA,EAAA,EAAE,iBAAiB,EAAE,OAAO,EAAG,CAAA,CAAA;AAClD,QAAA,KAAK,QAAQ;YACX,OAAY,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAA,KAAK,KAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAG,CAAA,CAAA;AAC/E,QAAA;AACE,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,IAAI,CAAA,CAAE,CAAC,CAAC;AACnD,KAAA;AACH,CAAC,CAAC;AAEF;;;;;;;;;;;;;;;AAeG;AACa,SAAA,sBAAsB,CAAC,EAAE,KAAK,EAAwB,EAAA;IACpE,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,UAAU,CAAC,mBAAmB,EAAE;AACxD,QAAA,iBAAiB,EAAE,KAAK;AACxB,QAAA,kBAAkB,EAAE,KAAK;AAC1B,KAAA,CAAC,CAAC;IAEH,SAAS,CAAC,MAAK;;;;AAIb,QAAA,MAAM,uBAAuB,GAAG,KAAK,KAAK,KAAK,CAAC,iBAAiB,CAAC;AAClE,QAAA,IAAI,uBAAuB,EAAE;;;;;;YAM3B,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;AAC9C,SAAA;KACF,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IAErC,OAAO;QACL,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;QAC5C,QAAQ;KACT,CAAC;AACJ;;;;;;;"}

package/es/hooks/UNSAFE_useDebounce.js

@@ -0,0 +1,43 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useState, useEffect } from '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
+ */
+/**
+ * A custom hook that debounces a value and only returns the latest value
+ * if there is no interaction for the specified delay
+ *
+ * @param value The value to be debounced
+ * @param delay The delay for the debouncing
+ */
+function useDebounce(value, delay) {
+    const [debouncedValue, setDebouncedValue] = useState(value);
+    useEffect(() => {
+        // update value after the specified delay
+        const timeoutId = setTimeout(() => {
+            setDebouncedValue(value);
+        }, delay);
+        // Cancel the timeout if the value or delay changes (also on unmount)
+        // so that the debounced value will not be updated if the value is changed
+        // within the delay period.
+        return () => clearTimeout(timeoutId);
+    }, [value, delay]);
+    return debouncedValue;
+}
+
+/**
+ * @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
+ */
+
+export { useDebounce };
+/*  */
+//# sourceMappingURL=UNSAFE_useDebounce.js.map

package/es/hooks/UNSAFE_useDebounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useDebounce.js","sources":["../../../src/hooks/UNSAFE_useDebounce/useDebounce.ts","../../../src/hooks/UNSAFE_useDebounce/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 { useEffect, useState } from 'preact/hooks';\n\n/**\n * A custom hook that debounces a value and only returns the latest value\n * if there is no interaction for the specified delay\n *\n * @param value The value to be debounced\n * @param delay The delay for the debouncing\n */\nexport function useDebounce<V>(value: V, delay: number) {\n  const [debouncedValue, setDebouncedValue] = useState(value);\n\n  useEffect(() => {\n    // update value after the specified delay\n    const timeoutId = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    // Cancel the timeout if the value or delay changes (also on unmount)\n    // so that the debounced value will not be updated if the value is changed\n    // within the delay period.\n    return () => clearTimeout(timeoutId);\n  }, [value, delay]);\n\n  return debouncedValue;\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 { useDebounce } from './useDebounce';\n"],"names":[],"mappings":";;;AAAA;;;;;;AAMG;AAGH;;;;;;AAMG;AACa,SAAA,WAAW,CAAI,KAAQ,EAAE,KAAa,EAAA;IACpD,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAE5D,SAAS,CAAC,MAAK;;AAEb,QAAA,MAAM,SAAS,GAAG,UAAU,CAAC,MAAK;YAChC,iBAAiB,CAAC,KAAK,CAAC,CAAC;SAC1B,EAAE,KAAK,CAAC,CAAC;;;;AAKV,QAAA,OAAO,MAAM,YAAY,CAAC,SAAS,CAAC,CAAC;AACvC,KAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAEnB,IAAA,OAAO,cAAc,CAAC;AACxB;;AChCA;;;;;;AAMG;;;;;;;"}

package/es/hooks/UNSAFE_useFloating.js

@@ -0,0 +1,12 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+export { v as autoPlacement, s as detectOverflow, b as flip, P as hide, E as inline, L as limitShift, o as offset, D as shift, k as size, u as useFloating } from '../index-14bba6f7.js';
+import 'preact/hooks';
+import './UNSAFE_useUser.js';
+import '../UNSAFE_Environment.js';
+import 'preact';
+import 'preact/jsx-runtime';
+import '../UNSAFE_Layer.js';
+import 'preact/compat';
+import '../utils/PRIVATE_floatingUtils.js';
+/*  */
+//# sourceMappingURL=UNSAFE_useFloating.js.map

package/es/hooks/UNSAFE_useFloating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFloating.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}

package/es/hooks/UNSAFE_useFocus.js

@@ -0,0 +1,33 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useToggle } from './UNSAFE_useToggle.js';
+import 'preact/hooks';
+
+/**
+ * Get status on whether target has focus or not
+ * @returns
+ */
+function useFocus(settings = { isDisabled: false }) {
+    const { bool, setTrue, setFalse } = useToggle(false);
+    const focusProps = settings.isDisabled
+        ? {}
+        : {
+            onFocus: setTrue,
+            onBlur: setFalse
+        };
+    return {
+        isFocus: settings.isDisabled ? false : bool,
+        focusProps: focusProps
+    };
+}
+
+/**
+ * @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
+ */
+
+export { useFocus };
+/*  */
+//# sourceMappingURL=UNSAFE_useFocus.js.map

package/es/hooks/UNSAFE_useFocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFocus.js","sources":["../../../src/hooks/UNSAFE_useFocus/useFocus.ts","../../../src/hooks/UNSAFE_useFocus/index.ts"],"sourcesContent":["import { useToggle } from '../UNSAFE_useToggle';\n\nexport type FocusOptions = {\n  isDisabled?: boolean;\n};\n\n/**\n * Get status on whether target has focus or not\n * @returns\n */\nexport function useFocus(settings: FocusOptions = { isDisabled: false }): {\n  isFocus: boolean;\n  focusProps: Record<string, any>;\n} {\n  const { bool, setTrue, setFalse } = useToggle(false);\n  const focusProps = settings.isDisabled\n    ? {}\n    : {\n        onFocus: setTrue,\n        onBlur: setFalse\n      };\n  return {\n    isFocus: settings.isDisabled ? false : bool,\n    focusProps: focusProps\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 { useFocus } from './useFocus';\n"],"names":[],"mappings":";;;;AAMA;;;AAGG;AACG,SAAU,QAAQ,CAAC,QAAA,GAAyB,EAAE,UAAU,EAAE,KAAK,EAAE,EAAA;AAIrE,IAAA,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;AACrD,IAAA,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU;AACpC,UAAE,EAAE;AACJ,UAAE;AACE,YAAA,OAAO,EAAE,OAAO;AAChB,YAAA,MAAM,EAAE,QAAQ;SACjB,CAAC;IACN,OAAO;QACL,OAAO,EAAE,QAAQ,CAAC,UAAU,GAAG,KAAK,GAAG,IAAI;AAC3C,QAAA,UAAU,EAAE,UAAU;KACvB,CAAC;AACJ;;ACzBA;;;;;;AAMG;;;;;;;"}

package/es/hooks/UNSAFE_useFocusWithin.js

@@ -0,0 +1,48 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useState, useRef, useCallback } from 'preact/hooks';
+
+function useFocusWithin({ isDisabled, onBlurWithin, onFocusWithin } = {}) {
+    const [isFocused, setIsFocused] = useState(false);
+    // Maintain a ref for whether we're focused so that we can update it synchronously and check
+    // it in the listeners.  It's possible for an element to receive and lose focus before
+    // the next render happens, in which case the isFocused state hasn't been updated yet for
+    // the focusin event.  The focusout listener would not do anything based on that stale state,
+    // which would result in the isFocused state incorrectly remaining true.
+    // We still need the isFocused state because that state change will trigger a rerender,
+    // whereas updating the ref will not.
+    const isFocusedRef = useRef(false);
+    const onfocusin = useCallback((event) => {
+        if (!isFocusedRef.current) {
+            onFocusWithin === null || onFocusWithin === void 0 ? void 0 : onFocusWithin(event);
+            setIsFocused(true);
+            isFocusedRef.current = true;
+        }
+    }, [onFocusWithin]);
+    const onfocusout = useCallback((event) => {
+        // Trigger focus event changes only when the focus goes outside of the current
+        // target. Ignore focus changes within the current target
+        if (isFocusedRef.current &&
+            (event.relatedTarget == null ||
+                !event.currentTarget.contains(event.relatedTarget))) {
+            onBlurWithin === null || onBlurWithin === void 0 ? void 0 : onBlurWithin(event);
+            setIsFocused(false);
+            isFocusedRef.current = false;
+        }
+    }, [onBlurWithin]);
+    return isDisabled
+        ? {
+            isFocused: false,
+            focusProps: {}
+        }
+        : {
+            isFocused,
+            focusProps: {
+                onfocusin,
+                onfocusout
+            }
+        };
+}
+
+export { useFocusWithin };
+/*  */
+//# sourceMappingURL=UNSAFE_useFocusWithin.js.map

package/es/hooks/UNSAFE_useFocusWithin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFocusWithin.js","sources":["../../../src/hooks/UNSAFE_useFocusWithin/useFocusWithin.ts"],"sourcesContent":["import { useCallback, useRef, useState } from 'preact/hooks';\n\ntype FocusEvents = {\n  onBlurWithin?: (e: FocusEvent) => void;\n  onFocusWithin?: (e: FocusEvent) => void;\n};\n\ntype UseFocusWithinProps = FocusEvents & {\n  isDisabled?: boolean;\n};\n\nexport function useFocusWithin({\n  isDisabled,\n  onBlurWithin,\n  onFocusWithin\n}: UseFocusWithinProps = {}) {\n  const [isFocused, setIsFocused] = useState(false);\n  // Maintain a ref for whether we're focused so that we can update it synchronously and check\n  // it in the listeners.  It's possible for an element to receive and lose focus before\n  // the next render happens, in which case the isFocused state hasn't been updated yet for\n  // the focusin event.  The focusout listener would not do anything based on that stale state,\n  // which would result in the isFocused state incorrectly remaining true.\n  // We still need the isFocused state because that state change will trigger a rerender,\n  // whereas updating the ref will not.\n  const isFocusedRef = useRef(false);\n  const onfocusin = useCallback(\n    (event: FocusEvent) => {\n      if (!isFocusedRef.current) {\n        onFocusWithin?.(event);\n        setIsFocused(true);\n        isFocusedRef.current = true;\n      }\n    },\n    [onFocusWithin]\n  );\n  const onfocusout = useCallback(\n    (event: FocusEvent) => {\n      // Trigger focus event changes only when the focus goes outside of the current\n      // target. Ignore focus changes within the current target\n      if (\n        isFocusedRef.current &&\n        (event.relatedTarget == null ||\n          !(event.currentTarget as HTMLElement).contains(event.relatedTarget as HTMLElement))\n      ) {\n        onBlurWithin?.(event);\n        setIsFocused(false);\n        isFocusedRef.current = false;\n      }\n    },\n    [onBlurWithin]\n  );\n\n  return isDisabled\n    ? {\n        isFocused: false,\n        focusProps: {}\n      }\n    : {\n        isFocused,\n        focusProps: {\n          onfocusin,\n          onfocusout\n        }\n      };\n}\n"],"names":[],"mappings":";;;AAWM,SAAU,cAAc,CAAC,EAC7B,UAAU,EACV,YAAY,EACZ,aAAa,EAAA,GACU,EAAE,EAAA;IACzB,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;;;;;;;;AAQlD,IAAA,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;AACnC,IAAA,MAAM,SAAS,GAAG,WAAW,CAC3B,CAAC,KAAiB,KAAI;AACpB,QAAA,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE;AACzB,YAAA,aAAa,aAAb,aAAa,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAb,aAAa,CAAG,KAAK,CAAC,CAAC;YACvB,YAAY,CAAC,IAAI,CAAC,CAAC;AACnB,YAAA,YAAY,CAAC,OAAO,GAAG,IAAI,CAAC;AAC7B,SAAA;AACH,KAAC,EACD,CAAC,aAAa,CAAC,CAChB,CAAC;AACF,IAAA,MAAM,UAAU,GAAG,WAAW,CAC5B,CAAC,KAAiB,KAAI;;;QAGpB,IACE,YAAY,CAAC,OAAO;AACpB,aAAC,KAAK,CAAC,aAAa,IAAI,IAAI;gBAC1B,CAAE,KAAK,CAAC,aAA6B,CAAC,QAAQ,CAAC,KAAK,CAAC,aAA4B,CAAC,CAAC,EACrF;AACA,YAAA,YAAY,aAAZ,YAAY,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAZ,YAAY,CAAG,KAAK,CAAC,CAAC;YACtB,YAAY,CAAC,KAAK,CAAC,CAAC;AACpB,YAAA,YAAY,CAAC,OAAO,GAAG,KAAK,CAAC;AAC9B,SAAA;AACH,KAAC,EACD,CAAC,YAAY,CAAC,CACf,CAAC;AAEF,IAAA,OAAO,UAAU;AACf,UAAE;AACE,YAAA,SAAS,EAAE,KAAK;AAChB,YAAA,UAAU,EAAE,EAAE;AACf,SAAA;AACH,UAAE;YACE,SAAS;AACT,YAAA,UAAU,EAAE;gBACV,SAAS;gBACT,UAAU;AACX,aAAA;SACF,CAAC;AACR;;;;;;;"}

package/es/hooks/UNSAFE_useFocusableTextField.js

@@ -0,0 +1,67 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { _ as __rest } from '../tslib.es6-8b94ba02.js';
+import { useRef, useEffect, useImperativeHandle } from 'preact/hooks';
+import { useFocusWithin } from './UNSAFE_useFocusWithin.js';
+
+/**
+ * A custom hook that handles the focus when the text field
+ * is toggled between readonly and enabled
+ * @typedef E represents the type of the enabled element
+ * @typedef R represents the type of the readonly element
+ */
+function useFocusableTextField(_a) {
+    var { isReadonly, ref = () => { } } = _a, useFocusWithinProps = __rest(_a, ["isReadonly", "ref"]);
+    const { focusProps, isFocused } = useFocusWithin(useFocusWithinProps);
+    const previousIsFocusedRef = useRef(isFocused);
+    const enabledElementRef = useRef(null);
+    const readonlyElementRef = useRef(null);
+    // Retain focus when toggling between readonly and enabled
+    useEffect(() => {
+        // if the readonly state is changed and previously we
+        // were holding focus, set the focus to newly rendered element
+        if (previousIsFocusedRef.current) {
+            if (isReadonly) {
+                setTimeout(() => { var _a; return (_a = readonlyElementRef.current) === null || _a === void 0 ? void 0 : _a.focus(); });
+            }
+            else {
+                setTimeout(() => { var _a; return (_a = enabledElementRef.current) === null || _a === void 0 ? void 0 : _a.focus(); });
+            }
+        }
+    }, [isReadonly]);
+    // Keep the previousFocusRef in sync, but be sure to run this hook
+    // after handling focus for the readonly toggling.
+    useEffect(() => {
+        previousIsFocusedRef.current = isFocused;
+    }, [isFocused]);
+    // Add focus and blur methods
+    useImperativeHandle(ref, () => ({
+        focus: () => {
+            var _a, _b;
+            if (isReadonly) {
+                (_a = readonlyElementRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+            else {
+                (_b = enabledElementRef.current) === null || _b === void 0 ? void 0 : _b.focus();
+            }
+        },
+        blur: () => {
+            var _a, _b;
+            if (isReadonly) {
+                (_a = readonlyElementRef.current) === null || _a === void 0 ? void 0 : _a.blur();
+            }
+            else {
+                (_b = enabledElementRef.current) === null || _b === void 0 ? void 0 : _b.blur();
+            }
+        }
+    }), [isReadonly]);
+    return {
+        enabledElementRef,
+        readonlyElementRef,
+        isFocused,
+        focusProps
+    };
+}
+
+export { useFocusableTextField };
+/*  */
+//# sourceMappingURL=UNSAFE_useFocusableTextField.js.map

package/es/hooks/UNSAFE_useFocusableTextField.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFocusableTextField.js","sources":["../../../src/hooks/UNSAFE_useFocusableTextField/useFocusableTextField.ts"],"sourcesContent":["import { Ref } from 'preact';\nimport { useEffect, useImperativeHandle, useRef } from 'preact/hooks';\nimport { useFocusWithin } from '../UNSAFE_useFocusWithin';\n\nexport type FocusableHandle = {\n  focus: () => void;\n  blur: () => void;\n};\ntype UseFocusWithinProps = Parameters<typeof useFocusWithin>[0];\ntype UseFocusableTextFieldProps = UseFocusWithinProps & {\n  /**\n   * flag indicating whether the field is readonly\n   */\n  isReadonly?: boolean;\n\n  /**\n   * An optional ref to add imperative handles\n   */\n  ref?: Ref<FocusableHandle>;\n};\n\n/**\n * A custom hook that handles the focus when the text field\n * is toggled between readonly and enabled\n * @typedef E represents the type of the enabled element\n * @typedef R represents the type of the readonly element\n */\nexport function useFocusableTextField<E extends HTMLElement, R extends HTMLElement>({\n  isReadonly,\n  ref = () => {},\n  ...useFocusWithinProps\n}: UseFocusableTextFieldProps) {\n  const { focusProps, isFocused } = useFocusWithin(useFocusWithinProps);\n\n  const previousIsFocusedRef = useRef(isFocused);\n  const enabledElementRef = useRef<E>(null);\n  const readonlyElementRef = useRef<R>(null);\n\n  // Retain focus when toggling between readonly and enabled\n  useEffect(() => {\n    // if the readonly state is changed and previously we\n    // were holding focus, set the focus to newly rendered element\n    if (previousIsFocusedRef.current) {\n      if (isReadonly) {\n        setTimeout(() => readonlyElementRef.current?.focus());\n      } else {\n        setTimeout(() => enabledElementRef.current?.focus());\n      }\n    }\n  }, [isReadonly]);\n\n  // Keep the previousFocusRef in sync, but be sure to run this hook\n  // after handling focus for the readonly toggling.\n  useEffect(() => {\n    previousIsFocusedRef.current = isFocused;\n  }, [isFocused]);\n\n  // Add focus and blur methods\n  useImperativeHandle(\n    ref,\n    () => ({\n      focus: () => {\n        if (isReadonly) {\n          readonlyElementRef.current?.focus();\n        } else {\n          enabledElementRef.current?.focus();\n        }\n      },\n      blur: () => {\n        if (isReadonly) {\n          readonlyElementRef.current?.blur();\n        } else {\n          enabledElementRef.current?.blur();\n        }\n      }\n    }),\n    [isReadonly]\n  );\n\n  return {\n    enabledElementRef,\n    readonlyElementRef,\n    isFocused,\n    focusProps\n  };\n}\n"],"names":[],"mappings":";;;;;AAqBA;;;;;AAKG;AACG,SAAU,qBAAqB,CAA+C,EAIvD,EAAA;AAJuD,IAAA,IAAA,EAClF,UAAU,EACV,GAAG,GAAG,MAAO,GAAC,EAEa,GAAA,EAAA,EADxB,mBAAmB,GAAA,MAAA,CAAA,EAAA,EAH4D,qBAInF,CADuB,CAAA;IAEtB,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,cAAc,CAAC,mBAAmB,CAAC,CAAC;AAEtE,IAAA,MAAM,oBAAoB,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;AAC/C,IAAA,MAAM,iBAAiB,GAAG,MAAM,CAAI,IAAI,CAAC,CAAC;AAC1C,IAAA,MAAM,kBAAkB,GAAG,MAAM,CAAI,IAAI,CAAC,CAAC;;IAG3C,SAAS,CAAC,MAAK;;;QAGb,IAAI,oBAAoB,CAAC,OAAO,EAAE;AAChC,YAAA,IAAI,UAAU,EAAE;AACd,gBAAA,UAAU,CAAC,MAAK,EAAA,IAAA,EAAA,CAAA,CAAC,OAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,0CAAE,KAAK,EAAE,CAAA,EAAA,CAAC,CAAC;AACvD,aAAA;AAAM,iBAAA;AACL,gBAAA,UAAU,CAAC,MAAK,EAAA,IAAA,EAAA,CAAA,CAAC,OAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,0CAAE,KAAK,EAAE,CAAA,EAAA,CAAC,CAAC;AACtD,aAAA;AACF,SAAA;AACH,KAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;;;IAIjB,SAAS,CAAC,MAAK;AACb,QAAA,oBAAoB,CAAC,OAAO,GAAG,SAAS,CAAC;AAC3C,KAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;;AAGhB,IAAA,mBAAmB,CACjB,GAAG,EACH,OAAO;QACL,KAAK,EAAE,MAAK;;AACV,YAAA,IAAI,UAAU,EAAE;AACd,gBAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,KAAK,EAAE,CAAC;AACrC,aAAA;AAAM,iBAAA;AACL,gBAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,KAAK,EAAE,CAAC;AACpC,aAAA;SACF;QACD,IAAI,EAAE,MAAK;;AACT,YAAA,IAAI,UAAU,EAAE;AACd,gBAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAI,EAAE,CAAC;AACpC,aAAA;AAAM,iBAAA;AACL,gBAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAI,EAAE,CAAC;AACnC,aAAA;SACF;AACF,KAAA,CAAC,EACF,CAAC,UAAU,CAAC,CACb,CAAC;IAEF,OAAO;QACL,iBAAiB;QACjB,kBAAkB;QAClB,SAAS;QACT,UAAU;KACX,CAAC;AACJ;;;;;;;"}

package/es/hooks/UNSAFE_useFormContext.js

@@ -0,0 +1,35 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { createContext } from 'preact';
+import { useContext } from 'preact/hooks';
+
+const DefaultFormContext = {
+    isDisabled: false,
+    isFormLayout: false,
+    isReadonly: false,
+    labelEdge: 'inside',
+    labelStartWidth: '33%',
+    labelWrapping: 'wrap',
+    textAlign: 'start',
+    userAssistanceDensity: 'reflow'
+};
+/**
+ * Context which the parent component can use to provide various FormLayout related
+ * information to descendant form controls.
+ */
+const FormContext = createContext(DefaultFormContext);
+
+/**
+ * Utility hook for consuming the FormContext
+ *
+ * @returns The value of closest FormContext provider
+ */
+function useFormContext() {
+    const context = useContext(FormContext);
+    // merge the returned context into the default context so that all props are specified
+    const contextWithDefaults = Object.assign({}, DefaultFormContext, context);
+    return contextWithDefaults;
+}
+
+export { FormContext, useFormContext };
+/*  */
+//# sourceMappingURL=UNSAFE_useFormContext.js.map

package/es/hooks/UNSAFE_useFormContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFormContext.js","sources":["../../../src/hooks/UNSAFE_useFormContext/FormContext.ts","../../../src/hooks/UNSAFE_useFormContext/useFormContext.ts"],"sourcesContent":["import { createContext } from 'preact';\nimport { Size } from '../../utils/UNSAFE_size';\n\n/**\n * Props of the FormContext\n */\n// TODO: investigate labelEdge, labelStartWidth, labelWrapping and see if they still need to be on the form components,\n// or if we can just use a FormContext to pass this to a single component when it isn't in a form layout. See JET-51152\ntype FormContextProps = {\n  /**\n   * Indicates whether the form layout is disabled.\n   */\n  isDisabled?: boolean;\n  /**\n   * Indicates whether the component is inside a form layout.\n   */\n  isFormLayout?: boolean;\n  /**\n   * Indicates whether the form layout is readonly.\n   */\n  isReadonly?: boolean;\n  /**\n   * Specifies the label position.\n   */\n  labelEdge?: 'inside' | 'start' | 'top';\n  /**\n   * Specifies the width of the start aligned label, ignored for top aligned.\n   */\n  labelStartWidth?: Size;\n  /**\n   * Specifies if start or top label text should wrap or truncate.\n   */\n  labelWrapping?: 'truncate' | 'wrap';\n  /**\n   * Specifies the text alignment of the value.\n   */\n  textAlign?: 'start' | 'end' | 'right';\n  /**\n   * Specifies the density of the user assistance presentation.\n   */\n  userAssistanceDensity?: 'reflow' | 'efficient';\n};\n\nconst DefaultFormContext: FormContextProps = {\n  isDisabled: false,\n  isFormLayout: false,\n  isReadonly: false,\n  labelEdge: 'inside',\n  labelStartWidth: '33%',\n  labelWrapping: 'wrap',\n  textAlign: 'start',\n  userAssistanceDensity: 'reflow'\n};\n\n/**\n * Context which the parent component can use to provide various FormLayout related\n * information to descendant form controls.\n */\nconst FormContext = createContext<FormContextProps>(DefaultFormContext);\n\nexport { DefaultFormContext, FormContext, FormContextProps };\n","import { useContext } from 'preact/hooks';\nimport { DefaultFormContext, FormContext } from './FormContext';\n\n/**\n * Utility hook for consuming the FormContext\n *\n * @returns The value of closest FormContext provider\n */\nfunction useFormContext() {\n  const context = useContext(FormContext);\n  // merge the returned context into the default context so that all props are specified\n  const contextWithDefaults = Object.assign({}, DefaultFormContext, context);\n  return contextWithDefaults;\n}\n\nexport { useFormContext };\n"],"names":[],"mappings":";;;;AA2CA,MAAM,kBAAkB,GAAqB;AAC3C,IAAA,UAAU,EAAE,KAAK;AACjB,IAAA,YAAY,EAAE,KAAK;AACnB,IAAA,UAAU,EAAE,KAAK;AACjB,IAAA,SAAS,EAAE,QAAQ;AACnB,IAAA,eAAe,EAAE,KAAK;AACtB,IAAA,aAAa,EAAE,MAAM;AACrB,IAAA,SAAS,EAAE,OAAO;AAClB,IAAA,qBAAqB,EAAE,QAAQ;CAChC,CAAC;AAEF;;;AAGG;AACH,MAAM,WAAW,GAAG,aAAa,CAAmB,kBAAkB;;ACvDtE;;;;AAIG;AACH,SAAS,cAAc,GAAA;AACrB,IAAA,MAAM,OAAO,GAAG,UAAU,CAAC,WAAW,CAAC,CAAC;;AAExC,IAAA,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;AAC3E,IAAA,OAAO,mBAAmB,CAAC;AAC7B;;;;;;;"}

package/es/hooks/UNSAFE_useFormFieldContext.js

@@ -0,0 +1,28 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { createContext } from 'preact';
+import { useContext } from 'preact/hooks';
+
+/**
+ * Context which the parent component can use to provide various FormControl related
+ * information
+ */
+const FormFieldContext = createContext({
+    hasValue: false,
+    isDisabled: false,
+    isFocused: false,
+    isLoading: false,
+    isReadonly: false
+});
+
+/**
+ * Utility hook for consuming the FormFieldContext
+ *
+ * @returns The value of closest FormControl provider
+ */
+function useFormFieldContext() {
+    return useContext(FormFieldContext);
+}
+
+export { FormFieldContext, useFormFieldContext };
+/*  */
+//# sourceMappingURL=UNSAFE_useFormFieldContext.js.map

package/es/hooks/UNSAFE_useFormFieldContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFormFieldContext.js","sources":["../../../src/hooks/UNSAFE_useFormFieldContext/FormFieldContext.ts","../../../src/hooks/UNSAFE_useFormFieldContext/useFormFieldContext.ts"],"sourcesContent":["import { createContext } from 'preact';\n\ntype DisabledFormFieldContext = {\n  /**\n   * Indicates whether the component has value\n   */\n  hasValue?: boolean;\n  /**\n   * Indicates whether the component is in disabled state\n   */\n  isDisabled: true;\n  /**\n   * A disabled field can never have focus\n   */\n  isFocused?: false;\n  /**\n   * Indicates whether the component is in a loading state\n   */\n  isLoading?: boolean;\n  /**\n   * A disabled field can never be readonly\n   */\n  isReadonly?: false;\n};\n\ntype EnabledFormFieldContext = {\n  /**\n   * Indicates whether the component has value\n   */\n  hasValue?: boolean;\n  /**\n   * Enabled field can never be disabled\n   */\n  isDisabled?: false;\n  /**\n   * Indicates whether the text field is in focused state\n   */\n  isFocused?: boolean;\n  /**\n   * Indicates whether the component is in a loading state\n   */\n  isLoading?: boolean;\n  /**\n   * Enabled field will not be readonly\n   */\n  isReadonly?: false;\n};\n\ntype ReadonlyFormFieldContext = {\n  /**\n   * Indicates whether the component has value\n   */\n  hasValue?: boolean;\n  /**\n   * Readonly field can never be disabled\n   */\n  isDisabled?: false;\n  /**\n   * Indicates whether the text field is in focused state\n   */\n  isFocused?: boolean;\n  /**\n   * Indicates whether the component is in a loading state\n   */\n  isLoading?: boolean;\n  /**\n   * Indicates whether the component is in readonly state\n   */\n  isReadonly: true;\n};\n\ntype FormFieldContextProps =\n  | DisabledFormFieldContext\n  | EnabledFormFieldContext\n  | ReadonlyFormFieldContext;\n\n/**\n * Context which the parent component can use to provide various FormControl related\n * information\n */\nconst FormFieldContext = createContext<FormFieldContextProps>({\n  hasValue: false,\n  isDisabled: false,\n  isFocused: false,\n  isLoading: false,\n  isReadonly: false\n});\n\nexport { FormFieldContext, FormFieldContextProps };\n","import { useContext } from 'preact/hooks';\nimport { FormFieldContext } from './FormFieldContext';\n\n/**\n * Utility hook for consuming the FormFieldContext\n *\n * @returns The value of closest FormControl provider\n */\nfunction useFormFieldContext() {\n  return useContext(FormFieldContext);\n}\n\nexport { useFormFieldContext };\n"],"names":[],"mappings":";;;;AA4EA;;;AAGG;AACG,MAAA,gBAAgB,GAAG,aAAa,CAAwB;AAC5D,IAAA,QAAQ,EAAE,KAAK;AACf,IAAA,UAAU,EAAE,KAAK;AACjB,IAAA,SAAS,EAAE,KAAK;AAChB,IAAA,SAAS,EAAE,KAAK;AAChB,IAAA,UAAU,EAAE,KAAK;AAClB,CAAA;;ACnFD;;;;AAIG;AACH,SAAS,mBAAmB,GAAA;AAC1B,IAAA,OAAO,UAAU,CAAC,gBAAgB,CAAC,CAAC;AACtC;;;;;;;"}

package/es/hooks/UNSAFE_useFormVariantContext.js

@@ -0,0 +1,22 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { createContext } from 'preact';
+import { useContext } from 'preact/hooks';
+
+/**
+ * Context which an ancestor component can use to provide a value for the 'variant' property
+ * of the descendant form fields.
+ */
+const FormVariantContext = createContext('default');
+
+/**
+ * Utility hook for consuming the FormVariantContext
+ *
+ * @returns The value of the closest FormVariantContext provider
+ */
+function useFormVariantContext() {
+    return useContext(FormVariantContext);
+}
+
+export { FormVariantContext, useFormVariantContext };
+/*  */
+//# sourceMappingURL=UNSAFE_useFormVariantContext.js.map

package/es/hooks/UNSAFE_useFormVariantContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFormVariantContext.js","sources":["../../../src/hooks/UNSAFE_useFormVariantContext/FormVariantContext.ts","../../../src/hooks/UNSAFE_useFormVariantContext/useFormVariantContext.ts"],"sourcesContent":["import { createContext } from 'preact';\n\n/**\n * Context which an ancestor component can use to provide a value for the 'variant' property\n * of the descendant form fields.\n */\nexport const FormVariantContext = createContext<'default' | 'embedded' | undefined>('default');\n","import { useContext } from 'preact/hooks';\nimport { FormVariantContext } from './FormVariantContext';\n\n/**\n * Utility hook for consuming the FormVariantContext\n *\n * @returns The value of the closest FormVariantContext provider\n */\nexport function useFormVariantContext() {\n  return useContext(FormVariantContext);\n}\n"],"names":[],"mappings":";;;;AAEA;;;AAGG;MACU,kBAAkB,GAAG,aAAa,CAAqC,SAAS;;ACH7F;;;;AAIG;SACa,qBAAqB,GAAA;AACnC,IAAA,OAAO,UAAU,CAAC,kBAAkB,CAAC,CAAC;AACxC;;;;;;;"}

package/es/hooks/UNSAFE_useHover.js

@@ -0,0 +1,62 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { useToggle } from './UNSAFE_useToggle.js';
+import 'preact/hooks';
+
+/**
+ * Returns listeners and status for hover
+ * If only visual changes are required, :hover is faster.
+ *
+ * @returns
+ */
+function useHover(settings = { isDisabled: false }) {
+    // :hover is faster than event handlers, but doesn't work for all platforms.
+    // For touch-first devices, the media query for hover is enough.
+    // Hybrid devices support hover upon pointer usage, but tapping would toggle hover state
+    // so disable :hover and use event handlers for such devices.
+    // Use getClientHints to check if hybrid
+    // const hybrid = getClientHints().isHybrid;
+    // Classes can be done via :
+    //     !isHybrid && compStyles.pseudohover,
+    //      isHybrid && isHover && compStyles.hover
+    // and the props can be done via:
+    //     const { hoverProps, isHover } = useHover( {isDisabled: isHybrid});
+    //
+    // For the algorithm below, There are 2 possible sequences:
+    // 1. A pointer (mouse, trackpad) would generate a mouseEnter event that would initiate hover.
+    // 2. A touch generates a touchstart/touchend/mouseEnter event sequence.
+    // Hover has no meaning in a touch context, so the isHover state should be avoided.
+    // To avoid, we set an ignore flag when a touchend is encountered.
+    // Each time mouseEnter is encountered, the flag is checked.
+    // If ignore, we know that it is a touch device, so don't set hover state.
+    // In all cases, reset the flag for the next sequence.
+    //
+    const { bool, setTrue, setFalse } = useToggle(false);
+    const { bool: ignore, setTrue: setIgnoreTrue, setFalse: setIgnoreFalse } = useToggle(false);
+    const startHover = () => {
+        if (ignore) {
+            setIgnoreFalse();
+        }
+        else {
+            setTrue();
+        }
+    };
+    const hoverProps = settings.isDisabled
+        ? {}
+        : { ontouchend: setIgnoreTrue, onMouseEnter: startHover, onMouseLeave: setFalse };
+    return {
+        isHover: settings.isDisabled ? false : bool,
+        hoverProps: hoverProps
+    };
+}
+
+/**
+ * @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
+ */
+
+export { useHover };
+/*  */
+//# sourceMappingURL=UNSAFE_useHover.js.map