@oracle/oraclejet-preact 14.0.0

package/cjs/hooks/UNSAFE_useBreakpoints.js

@@ -0,0 +1,53 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+
+/*
+ * TODO: These default breakpoints are temporary (will be set by Provider in the future)
+ *
+ * This object defines default breakpoints for screens and containers.
+ */
+const defaultBreakpoints = {
+    sm: '0px',
+    md: '600px',
+    lg: '1024px',
+    xl: '1440px'
+};
+/*
+ * Simple custom hook which returns the current breakpoints based on viewport width.
+ * The breakpoints are returned as an object that is a set of boolean values keyed to each breakpoint.
+ * The window/viewport min-width is matched against a range of pixel values defined as the breakpoints.
+ *
+ * TODO: Investigate useBreakpoints scalability if a component that uses useBreakpoints ends up being stamped out in some collection component (JET-49558)
+ *
+ * TODO: Parameterize this hook type such that we enable type checking on the returned record key; introduce a type parameter that corresponds to the Record key type
+ */
+function useBreakpoints(breakpoints = defaultBreakpoints) {
+    // this handler will return current breakpoints as a single object we can watch, rather than looping through each breakpoint key
+    const queryMatches = hooks.useCallback(() => {
+        const currentMatches = {};
+        Object.entries(breakpoints).forEach(([key, value]) => {
+            currentMatches[key] = window.matchMedia(`(min-width: ${value})`).matches;
+        });
+        return currentMatches;
+    }, [breakpoints]);
+    const [matches, setMatches] = hooks.useState(() => queryMatches());
+    hooks.useEffect(() => {
+        const onResize = () => {
+            setMatches(queryMatches());
+        };
+        window.addEventListener('resize', onResize);
+        return () => {
+            window.removeEventListener('resize', onResize);
+        };
+    }, [queryMatches]);
+    return matches;
+}
+
+exports.defaultBreakpoints = defaultBreakpoints;
+exports.useBreakpoints = useBreakpoints;
+/*  */
+//# sourceMappingURL=UNSAFE_useBreakpoints.js.map

package/cjs/hooks/UNSAFE_useBreakpoints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useBreakpoints.js","sources":["../../../src/hooks/UNSAFE_useBreakpoints/useBreakpoints.ts"],"sourcesContent":["import { useState, useEffect, useCallback } from 'preact/hooks';\n\n/*\n * TODO: These default breakpoints are temporary (will be set by Provider in the future)\n *\n * This object defines default breakpoints for screens and containers.\n */\nexport const defaultBreakpoints = {\n  sm: '0px',\n  md: '600px',\n  lg: '1024px',\n  xl: '1440px'\n};\n\nexport type Breakpoints = Record<string, string>;\n\n/*\n * Simple custom hook which returns the current breakpoints based on viewport width.\n * The breakpoints are returned as an object that is a set of boolean values keyed to each breakpoint.\n * The window/viewport min-width is matched against a range of pixel values defined as the breakpoints.\n *\n * TODO: Investigate useBreakpoints scalability if a component that uses useBreakpoints ends up being stamped out in some collection component (JET-49558)\n *\n * TODO: Parameterize this hook type such that we enable type checking on the returned record key; introduce a type parameter that corresponds to the Record key type\n */\nexport function useBreakpoints(breakpoints: Breakpoints = defaultBreakpoints) {\n  // this handler will return current breakpoints as a single object we can watch, rather than looping through each breakpoint key\n  const queryMatches = useCallback(() => {\n    const currentMatches: Record<string, boolean> = {};\n    Object.entries(breakpoints).forEach(([key, value]) => {\n      currentMatches[key] = window.matchMedia(`(min-width: ${value})`).matches;\n    });\n    return currentMatches;\n  }, [breakpoints]);\n\n  const [matches, setMatches] = useState(() => queryMatches());\n\n  useEffect(() => {\n    const onResize = () => {\n      setMatches(queryMatches());\n    };\n\n    window.addEventListener('resize', onResize);\n    return () => {\n      window.removeEventListener('resize', onResize);\n    };\n  }, [queryMatches]);\n\n  return matches;\n}\n"],"names":["useCallback","useState","useEffect"],"mappings":";;;;;;;AAEA;;;;AAIG;AACU,MAAA,kBAAkB,GAAG;AAChC,IAAA,EAAE,EAAE,KAAK;AACT,IAAA,EAAE,EAAE,OAAO;AACX,IAAA,EAAE,EAAE,QAAQ;AACZ,IAAA,EAAE,EAAE,QAAQ;EACZ;AAIF;;;;;;;;AAQG;AACa,SAAA,cAAc,CAAC,WAAA,GAA2B,kBAAkB,EAAA;;AAE1E,IAAA,MAAM,YAAY,GAAGA,iBAAW,CAAC,MAAK;QACpC,MAAM,cAAc,GAA4B,EAAE,CAAC;AACnD,QAAA,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,KAAI;AACnD,YAAA,cAAc,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA,YAAA,EAAe,KAAK,CAAA,CAAA,CAAG,CAAC,CAAC,OAAO,CAAC;AAC3E,SAAC,CAAC,CAAC;AACH,QAAA,OAAO,cAAc,CAAC;AACxB,KAAC,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC;AAElB,IAAA,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,GAAGC,cAAQ,CAAC,MAAM,YAAY,EAAE,CAAC,CAAC;IAE7DC,eAAS,CAAC,MAAK;QACb,MAAM,QAAQ,GAAG,MAAK;AACpB,YAAA,UAAU,CAAC,YAAY,EAAE,CAAC,CAAC;AAC7B,SAAC,CAAC;AAEF,QAAA,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AAC5C,QAAA,OAAO,MAAK;AACV,YAAA,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACjD,SAAC,CAAC;AACJ,KAAC,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;AAEnB,IAAA,OAAO,OAAO,CAAC;AACjB;;;;;;;;"}

package/cjs/hooks/UNSAFE_useClearIcon.js

@@ -0,0 +1,24 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+var hooks_UNSAFE_useToggle = require('./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 = hooks.useCallback(() => isEnabled &&
+        (display === 'always' || (display === 'conditionally' && hasValue && (isFocused || isHover))), [display, hasValue, isEnabled, isFocused, isHover]);
+    const { bool, setFalse, setTrue } = hooks_UNSAFE_useToggle.useToggle(shouldRenderClearIcon());
+    hooks.useEffect(() => {
+        shouldRenderClearIcon() ? setTrue() : setFalse();
+    }, [shouldRenderClearIcon]);
+    return bool ? clearIcon : null;
+}
+
+exports.useClearIcon = useClearIcon;
+/*  */
+//# sourceMappingURL=UNSAFE_useClearIcon.js.map

package/cjs/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":["useCallback","useToggle","useEffect"],"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,GAAGA,iBAAW,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,GAAGC,gCAAS,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAEvEC,eAAS,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/cjs/hooks/UNSAFE_useColorScheme.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 useColorScheme() {
+    return hooks.useContext(UNSAFE_Environment.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
+ */
+
+exports.useColorScheme = useColorScheme;
+/*  */
+//# sourceMappingURL=UNSAFE_useColorScheme.js.map

package/cjs/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":["useContext","EnvironmentContext"],"mappings":";;;;;;;;;;;;AAAA;;;;;;AAMG;SAIa,cAAc,GAAA;AAC5B,IAAA,OAAOA,gBAAU,CAACC,qCAAkB,CAAC,CAAC,WAAW,CAAC;AACpD;;ACZA;;;;;;AAMG;;;;;;;"}

package/cjs/hooks/UNSAFE_useContainerBreakpointValues.js

@@ -0,0 +1,26 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks_UNSAFE_useContainerBreakpoints = require('./UNSAFE_useContainerBreakpoints.js');
+var hooks_UNSAFE_useBreakpoints = require('./UNSAFE_useBreakpoints.js');
+require('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 = hooks_UNSAFE_useBreakpoints.defaultBreakpoints) {
+    const { breakpointMatches, ref } = hooks_UNSAFE_useContainerBreakpoints.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 };
+}
+
+exports.useContainerBreakpointValues = useContainerBreakpointValues;
+/*  */
+//# sourceMappingURL=UNSAFE_useContainerBreakpointValues.js.map

package/cjs/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":["defaultBreakpoints","useContainerBreakpoints"],"mappings":";;;;;;;;;AAWA;;;AAGG;SACa,4BAA4B,CAC1C,gBAA+B,EAC/B,cAA2BA,8CAAkB,EAAA;IAE7C,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,GAAGC,4DAAuB,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/cjs/hooks/UNSAFE_useContainerBreakpoints.js

@@ -0,0 +1,47 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('preact/hooks');
+var hooks_UNSAFE_useBreakpoints = require('./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 = hooks_UNSAFE_useBreakpoints.defaultBreakpoints) {
+    const [width, setWidth] = hooks.useState(0);
+    const observedNodeRef = hooks.useRef(null);
+    const resizeObserver = hooks.useMemo(() => new ResizeObserver((entries) => {
+        for (const entry of entries) {
+            setWidth(entry.contentRect.width);
+        }
+    }), []);
+    const ref = hooks.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 = hooks.useMemo(() => {
+        const matches = {};
+        for (const k in breakpoints) {
+            matches[k] = width >= parseInt(breakpoints[k]);
+        }
+        return matches;
+    }, [width, breakpoints]);
+    return { breakpointMatches, ref };
+}
+
+exports.useContainerBreakpoints = useContainerBreakpoints;
+/*  */
+//# sourceMappingURL=UNSAFE_useContainerBreakpoints.js.map

package/cjs/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":["defaultBreakpoints","useState","useRef","useMemo","useCallback"],"mappings":";;;;;;;;AAGA;;;;;AAKG;AACa,SAAA,uBAAuB,CAAC,WAAA,GAA2BA,8CAAkB,EAAA;IACnF,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAGC,cAAQ,CAAC,CAAC,CAAC,CAAC;AACtC,IAAA,MAAM,eAAe,GAAGC,YAAM,CAAqB,IAAI,CAAC,CAAC;AAEzD,IAAA,MAAM,cAAc,GAAGC,aAAO,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,GAAGC,iBAAW,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,GAAGD,aAAO,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/cjs/hooks/UNSAFE_useCurrentValueReducer.js

@@ -0,0 +1,61 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks = require('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] = hooks.useReducer(currentValueReducer, {
+        currentInputValue: value,
+        currentCommitValue: value
+    });
+    hooks.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
+    };
+}
+
+exports.useCurrentValueReducer = useCurrentValueReducer;
+/*  */
+//# sourceMappingURL=UNSAFE_useCurrentValueReducer.js.map

package/cjs/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":["useReducer","useEffect"],"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,GAAGA,gBAAU,CAAC,mBAAmB,EAAE;AACxD,QAAA,iBAAiB,EAAE,KAAK;AACxB,QAAA,kBAAkB,EAAE,KAAK;AAC1B,KAAA,CAAC,CAAC;IAEHC,eAAS,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/cjs/hooks/UNSAFE_useDebounce.js

@@ -0,0 +1,47 @@
+/* @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
+ */
+/**
+ * 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] = hooks.useState(value);
+    hooks.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
+ */
+
+exports.useDebounce = useDebounce;
+/*  */
+//# sourceMappingURL=UNSAFE_useDebounce.js.map

package/cjs/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":["useState","useEffect"],"mappings":";;;;;;;AAAA;;;;;;AAMG;AAGH;;;;;;AAMG;AACa,SAAA,WAAW,CAAI,KAAQ,EAAE,KAAa,EAAA;IACpD,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,GAAGA,cAAQ,CAAC,KAAK,CAAC,CAAC;IAE5DC,eAAS,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/cjs/hooks/UNSAFE_useFloating.js

@@ -0,0 +1,29 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks_UNSAFE_useFloating = require('../index-94b1ff28.js');
+require('preact/hooks');
+require('./UNSAFE_useUser.js');
+require('../UNSAFE_Environment.js');
+require('preact');
+require('preact/jsx-runtime');
+require('../UNSAFE_Layer.js');
+require('preact/compat');
+require('../utils/PRIVATE_floatingUtils.js');
+
+
+
+exports.autoPlacement = hooks_UNSAFE_useFloating.v;
+exports.detectOverflow = hooks_UNSAFE_useFloating.s;
+exports.flip = hooks_UNSAFE_useFloating.b;
+exports.hide = hooks_UNSAFE_useFloating.P;
+exports.inline = hooks_UNSAFE_useFloating.E;
+exports.limitShift = hooks_UNSAFE_useFloating.L;
+exports.offset = hooks_UNSAFE_useFloating.offset;
+exports.shift = hooks_UNSAFE_useFloating.D;
+exports.size = hooks_UNSAFE_useFloating.k;
+exports.useFloating = hooks_UNSAFE_useFloating.useFloating;
+/*  */
+//# sourceMappingURL=UNSAFE_useFloating.js.map

package/cjs/hooks/UNSAFE_useFloating.js.map

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

package/cjs/hooks/UNSAFE_useFocus.js

@@ -0,0 +1,37 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hooks_UNSAFE_useToggle = require('./UNSAFE_useToggle.js');
+require('preact/hooks');
+
+/**
+ * Get status on whether target has focus or not
+ * @returns
+ */
+function useFocus(settings = { isDisabled: false }) {
+    const { bool, setTrue, setFalse } = hooks_UNSAFE_useToggle.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
+ */
+
+exports.useFocus = useFocus;
+/*  */
+//# sourceMappingURL=UNSAFE_useFocus.js.map

package/cjs/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":["useToggle"],"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,GAAGA,gCAAS,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/cjs/hooks/UNSAFE_useFocusWithin.js

@@ -0,0 +1,13 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useFocusWithin = require('../useFocusWithin-e524661e.js');
+require('preact/hooks');
+
+
+
+exports.useFocusWithin = useFocusWithin.useFocusWithin;
+/*  */
+//# sourceMappingURL=UNSAFE_useFocusWithin.js.map

package/cjs/hooks/UNSAFE_useFocusWithin.js.map

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

package/cjs/hooks/UNSAFE_useFocusableTextField.js

@@ -0,0 +1,72 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('../tslib.es6-d7adde1f.js');
+var hooks = require('preact/hooks');
+require('./UNSAFE_useFocusWithin.js');
+var useFocusWithin = require('../useFocusWithin-e524661e.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 = tslib_es6.__rest(_a, ["isReadonly", "ref"]);
+    const { focusProps, isFocused } = useFocusWithin.useFocusWithin(useFocusWithinProps);
+    const previousIsFocusedRef = hooks.useRef(isFocused);
+    const enabledElementRef = hooks.useRef(null);
+    const readonlyElementRef = hooks.useRef(null);
+    // Retain focus when toggling between readonly and enabled
+    hooks.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.
+    hooks.useEffect(() => {
+        previousIsFocusedRef.current = isFocused;
+    }, [isFocused]);
+    // Add focus and blur methods
+    hooks.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
+    };
+}
+
+exports.useFocusableTextField = useFocusableTextField;
+/*  */
+//# sourceMappingURL=UNSAFE_useFocusableTextField.js.map

package/cjs/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":["__rest","useFocusWithin","useRef","useEffect","useImperativeHandle"],"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,GAAAA,gBAAA,CAAA,EAAA,EAH4D,qBAInF,CADuB,CAAA;IAEtB,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAGC,6BAAc,CAAC,mBAAmB,CAAC,CAAC;AAEtE,IAAA,MAAM,oBAAoB,GAAGC,YAAM,CAAC,SAAS,CAAC,CAAC;AAC/C,IAAA,MAAM,iBAAiB,GAAGA,YAAM,CAAI,IAAI,CAAC,CAAC;AAC1C,IAAA,MAAM,kBAAkB,GAAGA,YAAM,CAAI,IAAI,CAAC,CAAC;;IAG3CC,eAAS,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;;;IAIjBA,eAAS,CAAC,MAAK;AACb,QAAA,oBAAoB,CAAC,OAAO,GAAG,SAAS,CAAC;AAC3C,KAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;;AAGhB,IAAAC,yBAAmB,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/cjs/hooks/UNSAFE_useFormContext.js

@@ -0,0 +1,40 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var preact = require('preact');
+var hooks = require('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 = preact.createContext(DefaultFormContext);
+
+/**
+ * Utility hook for consuming the FormContext
+ *
+ * @returns The value of closest FormContext provider
+ */
+function useFormContext() {
+    const context = hooks.useContext(FormContext);
+    // merge the returned context into the default context so that all props are specified
+    const contextWithDefaults = Object.assign({}, DefaultFormContext, context);
+    return contextWithDefaults;
+}
+
+exports.FormContext = FormContext;
+exports.useFormContext = useFormContext;
+/*  */
+//# sourceMappingURL=UNSAFE_useFormContext.js.map

package/cjs/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":["createContext","useContext"],"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,GAAGA,oBAAa,CAAmB,kBAAkB;;ACvDtE;;;;AAIG;AACH,SAAS,cAAc,GAAA;AACrB,IAAA,MAAM,OAAO,GAAGC,gBAAU,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/cjs/hooks/UNSAFE_useFormFieldContext.js

@@ -0,0 +1,33 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var preact = require('preact');
+var hooks = require('preact/hooks');
+
+/**
+ * Context which the parent component can use to provide various FormControl related
+ * information
+ */
+const FormFieldContext = preact.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 hooks.useContext(FormFieldContext);
+}
+
+exports.FormFieldContext = FormFieldContext;
+exports.useFormFieldContext = useFormFieldContext;
+/*  */
+//# sourceMappingURL=UNSAFE_useFormFieldContext.js.map

package/cjs/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":["createContext","useContext"],"mappings":";;;;;;;;AA4EA;;;AAGG;AACG,MAAA,gBAAgB,GAAGA,oBAAa,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,OAAOC,gBAAU,CAAC,gBAAgB,CAAC,CAAC;AACtC;;;;;;;;"}