@oracle/oraclejet-preact 14.0.5 → 14.0.7

package/amd/hooks/UNSAFE_useColorScheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"UNSAFE_useColorScheme.js","sources":["../../../src/hooks/UNSAFE_useColorScheme/useColorScheme.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"],"names":["useContext","EnvironmentContext","colorScheme"],"mappings":"2LAWE,OAAOA,EAAUA,WAACC,sBAAoBC"}
+{"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":";;;IAAA;;;;;;IAMG;aAIa,cAAc,GAAA;IAC5B,IAAA,OAAOA,gBAAU,CAACC,qCAAkB,CAAC,CAAC,WAAW,CAAC;IACpD;;ICZA;;;;;;IAMG;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useContainerBreakpointValues.js

@@ -1,2 +1,24 @@
-define(["exports","./UNSAFE_useContainerBreakpoints","./UNSAFE_useBreakpoints","preact/hooks"],function(e,t,n,r){"use strict";e.useContainerBreakpointValues=function(e,r=n.defaultBreakpoints){const{breakpointMatches:o,ref:s}=t.useContainerBreakpoints(r);return{breakpoint:Object.entries(e).reduce((e,t)=>{const n=t[0];return o[n]?t:e})[1],ref:s}},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', './UNSAFE_useContainerBreakpoints', './UNSAFE_useBreakpoints', 'preact/hooks'], (function (exports, hooks_UNSAFE_useContainerBreakpoints, hooks_UNSAFE_useBreakpoints, hooks) { 'use strict';
+
+    /*
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useContainerBreakpointValues.js.map

package/amd/hooks/UNSAFE_useContainerBreakpointValues.js.map

@@ -1 +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":["breakpointValues","breakpoints","defaultBreakpoints","breakpointMatches","ref","useContainerBreakpoints","breakpoint","Object","entries","reduce","p","c","key"],"mappings":"sKAgBEA,EACAC,EAA2BC,sBAE3B,MAAMC,kBAAEA,EAAiBC,IAAEA,GAAQC,EAAuBA,wBAACJ,GAS3D,MAAO,CAAEK,WAPMC,OAAOC,QAAQR,GAAkBS,OAAO,CAACC,EAAGC,KACzD,MAAMC,EAAMD,EAAE,GACd,OAAOR,EAAkBS,GAAOD,EAAID,IAGZ,GAELN,IAAAA"}
+{"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":";;;IAWA;;;IAGG;aACa,4BAA4B,CAC1C,gBAA+B,EAC/B,cAA2BA,8CAAkB,EAAA;QAE7C,MAAM,EAAE,iBAAiB,EAAE,GAAG,EAAE,GAAGC,4DAAuB,CAAC,WAAW,CAAC,CAAC;IAExE,IAAA,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAI;YAC9D,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACjB,QAAA,OAAO,iBAAiB,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,KAAC,CAAC,CAAC;QAEH,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAE7B,IAAA,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;IAC7B;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useContainerBreakpoints.js

@@ -1,2 +1,46 @@
-define(["exports","preact/hooks","./UNSAFE_useBreakpoints"],function(e,t,n){"use strict";e.useContainerBreakpoints=function(e=n.defaultBreakpoints){const[r,s]=t.useState(0),o=t.useRef(null),u=t.useMemo(()=>new ResizeObserver(e=>{for(const t of e)s(t.contentRect.width)}),[]),c=t.useCallback(e=>{const t=o.current;e!=t&&(t&&u.unobserve(t),e&&u.observe(e),o.current=e)},[u]);return{breakpointMatches:t.useMemo(()=>{const t={};for(const n in e)t[n]=r>=parseInt(e[n]);return t},[r,e]),ref:c}},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact/hooks', './UNSAFE_useBreakpoints'], (function (exports, hooks, hooks_UNSAFE_useBreakpoints) { 'use strict';
+
+    /*
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useContainerBreakpoints.js.map

package/amd/hooks/UNSAFE_useContainerBreakpoints.js.map

@@ -1 +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":["breakpoints","defaultBreakpoints","width","setWidth","useState","observedNodeRef","useRef","resizeObserver","useMemo","ResizeObserver","entries","entry","contentRect","ref","useCallback","node","observedNode","current","unobserve","observe","breakpointMatches","matches","k","parseInt"],"mappings":"mHASgB,SAAwBA,EAA2BC,sBACjE,MAAOC,EAAOC,GAAYC,EAAQA,SAAC,GAC7BC,EAAkBC,SAA2B,MAE7CC,EAAiBC,EAAOA,QAC5B,IACE,IAAIC,eAAgBC,IAClB,IAAK,MAAMC,KAASD,EAClBP,EAASQ,EAAMC,YAAYV,SAGjC,IAGIW,EAAMC,cACTC,IACC,MAAMC,EAAeX,EAAgBY,QAEjCF,GAAQC,IACNA,GACFT,EAAeW,UAAUF,GAGvBD,GACFR,EAAeY,QAAQJ,GAGzBV,EAAgBY,QAAUF,IAG9B,CAACR,IAWH,MAAO,CAAEa,kBARiBZ,EAAAA,QAAQ,KAChC,MAAMa,EAAmC,GACzC,IAAK,MAAMC,KAAKtB,EACdqB,EAAQC,GAAKpB,GAASqB,SAASvB,EAAYsB,IAE7C,OAAOD,GACN,CAACnB,EAAOF,IAEiBa,IAAAA"}
+{"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":";;;IAGA;;;;;IAKG;IACa,SAAA,uBAAuB,CAAC,WAAA,GAA2BA,8CAAkB,EAAA;QACnF,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAGC,cAAQ,CAAC,CAAC,CAAC,CAAC;IACtC,IAAA,MAAM,eAAe,GAAGC,YAAM,CAAqB,IAAI,CAAC,CAAC;IAEzD,IAAA,MAAM,cAAc,GAAGC,aAAO,CAC5B,MACE,IAAI,cAAc,CAAC,CAAC,OAAO,KAAI;IAC7B,QAAA,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;IAC3B,YAAA,QAAQ,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;IACnC,SAAA;IACH,KAAC,CAAC,EACJ,EAAE,CACH,CAAC;IAEF,IAAA,MAAM,GAAG,GAAGC,iBAAW,CACrB,CAAC,IAAiB,KAAI;IACpB,QAAA,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC;YAE7C,IAAI,IAAI,IAAI,YAAY,EAAE;IACxB,YAAA,IAAI,YAAY,EAAE;IAChB,gBAAA,cAAc,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;IACxC,aAAA;IAED,YAAA,IAAI,IAAI,EAAE;IACR,gBAAA,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,aAAA;IAED,YAAA,eAAe,CAAC,OAAO,GAAG,IAAI,CAAC;IAChC,SAAA;IACH,KAAC,EACD,CAAC,cAAc,CAAC,CACjB,CAAC;IAEF,IAAA,MAAM,iBAAiB,GAAGD,aAAO,CAAC,MAAK;YACrC,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,QAAA,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE;IAC3B,YAAA,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,SAAA;IACD,QAAA,OAAO,OAAO,CAAC;IACjB,KAAC,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC;IAEzB,IAAA,OAAO,EAAE,iBAAiB,EAAE,GAAG,EAAE,CAAC;IACpC;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useCurrentValueReducer.js

@@ -1,2 +1,61 @@
-define(["exports","preact/hooks"],function(e,t){"use strict";const u=(e,{type:t,payload:u})=>{switch(t){case"input":return Object.assign(Object.assign({},e),{currentInputValue:u});case"commit":return Object.assign(Object.assign({},e),{currentCommitValue:u,currentInputValue:u});default:throw new Error(`Unknown action type: ${t}`)}};e.useCurrentValueReducer=function({value:e}){const[r,n]=t.useReducer(u,{currentInputValue:e,currentCommitValue:e});return t.useEffect(()=>{e!==r.currentInputValue&&n({type:"commit",payload:e})},[e,r.currentInputValue]),{currentCommitValue:r.currentCommitValue,dispatch:n}},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact/hooks'], (function (exports, hooks) { 'use strict';
+
+    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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useCurrentValueReducer.js.map

package/amd/hooks/UNSAFE_useCurrentValueReducer.js.map

@@ -1 +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":["currentValueReducer","state","type","payload","Object","assign","currentInputValue","currentCommitValue","Error","value","dispatch","useReducer","useEffect"],"mappings":"6DAoBA,MAAMA,EAAsB,CAC1BC,GACEC,KAAAA,EAAMC,QAAAA,MAER,OAAQD,GACN,IAAK,QACH,OAAAE,OAAAC,OAAAD,OAAAC,OAAA,GAAYJ,GAAK,CAAEK,kBAAmBH,IACxC,IAAK,SACH,OAAYC,OAAAC,OAAAD,OAAAC,OAAA,GAAAJ,IAAOM,mBAAoBJ,EAASG,kBAAmBH,IACrE,QACE,MAAM,IAAIK,MAAM,wBAAwBN,gCAoB9B,UAAuBO,MAAEA,IACvC,MAAOR,EAAOS,GAAYC,EAAAA,WAAWX,EAAqB,CACxDM,kBAAmBG,EACnBF,mBAAoBE,IAkBtB,OAfAG,EAAAA,UAAU,KAIwBH,IAAUR,EAAMK,mBAO9CI,EAAS,CAAER,KAAM,SAAUC,QAASM,KAErC,CAACA,EAAOR,EAAMK,oBAEV,CACLC,mBAAoBN,EAAMM,mBAC1BG,SAAAA"}
+{"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":";;;IAoBA,MAAM,mBAAmB,GAAG,CAC1B,KAAwB,EACxB,EAAE,IAAI,EAAE,OAAO,EAA8B,KAC3C;IACF,IAAA,QAAQ,IAAI;IACV,QAAA,KAAK,OAAO;IACV,YAAA,OAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAY,KAAK,CAAA,EAAA,EAAE,iBAAiB,EAAE,OAAO,EAAG,CAAA,CAAA;IAClD,QAAA,KAAK,QAAQ;gBACX,OAAY,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,MAAA,CAAA,EAAA,EAAA,KAAK,KAAE,kBAAkB,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAG,CAAA,CAAA;IAC/E,QAAA;IACE,YAAA,MAAM,IAAI,KAAK,CAAC,wBAAwB,IAAI,CAAA,CAAE,CAAC,CAAC;IACnD,KAAA;IACH,CAAC,CAAC;IAEF;;;;;;;;;;;;;;;IAeG;IACa,SAAA,sBAAsB,CAAC,EAAE,KAAK,EAAwB,EAAA;QACpE,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAGA,gBAAU,CAAC,mBAAmB,EAAE;IACxD,QAAA,iBAAiB,EAAE,KAAK;IACxB,QAAA,kBAAkB,EAAE,KAAK;IAC1B,KAAA,CAAC,CAAC;QAEHC,eAAS,CAAC,MAAK;;;;IAIb,QAAA,MAAM,uBAAuB,GAAG,KAAK,KAAK,KAAK,CAAC,iBAAiB,CAAC;IAClE,QAAA,IAAI,uBAAuB,EAAE;;;;;;gBAM3B,QAAQ,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9C,SAAA;SACF,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;QAErC,OAAO;YACL,kBAAkB,EAAE,KAAK,CAAC,kBAAkB;YAC5C,QAAQ;SACT,CAAC;IACJ;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useDebounce.js

@@ -1,2 +1,47 @@
-define(["exports","preact/hooks"],function(e,t){"use strict";e.useDebounce=function(e,u){const[o,n]=t.useState(e);return t.useEffect(()=>{const t=setTimeout(()=>{n(e)},u);return()=>clearTimeout(t)},[e,u]),o},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact/hooks'], (function (exports, hooks) { 'use strict';
+
+    /**
+     * @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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useDebounce.js.map

package/amd/hooks/UNSAFE_useDebounce.js.map

@@ -1 +1 @@
-{"version":3,"file":"UNSAFE_useDebounce.js","sources":["../../../src/hooks/UNSAFE_useDebounce/useDebounce.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"],"names":["value","delay","debouncedValue","setDebouncedValue","useState","useEffect","timeoutId","setTimeout","clearTimeout"],"mappings":"2EAgBgB,SAAeA,EAAUC,GACvC,MAAOC,EAAgBC,GAAqBC,EAAQA,SAACJ,GAcrD,OAZAK,EAAAA,UAAU,KAER,MAAMC,EAAYC,WAAW,KAC3BJ,EAAkBH,IACjBC,GAKH,MAAO,IAAMO,aAAaF,IACzB,CAACN,EAAOC,IAEJC"}
+{"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":";;;IAAA;;;;;;IAMG;IAGH;;;;;;IAMG;IACa,SAAA,WAAW,CAAI,KAAQ,EAAE,KAAa,EAAA;QACpD,MAAM,CAAC,cAAc,EAAE,iBAAiB,CAAC,GAAGA,cAAQ,CAAC,KAAK,CAAC,CAAC;QAE5DC,eAAS,CAAC,MAAK;;IAEb,QAAA,MAAM,SAAS,GAAG,UAAU,CAAC,MAAK;gBAChC,iBAAiB,CAAC,KAAK,CAAC,CAAC;aAC1B,EAAE,KAAK,CAAC,CAAC;;;;IAKV,QAAA,OAAO,MAAM,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,KAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IAEnB,IAAA,OAAO,cAAc,CAAC;IACxB;;IChCA;;;;;;IAMG;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useFloating.js

@@ -1,2 +1,21 @@
-define(["exports","../index-4f4526ef","preact/hooks","./UNSAFE_useUser","../UNSAFE_Environment","preact","preact/jsx-runtime","../UNSAFE_Layer","preact/compat","../utils/PRIVATE_floatingUtils"],function(e,t,i,s,n,o,f,r,a,l){"use strict";e.autoPlacement=t.v,e.detectOverflow=t.s,e.flip=t.b,e.hide=t.P,e.inline=t.E,e.limitShift=t.L,e.offset=t.offset,e.shift=t.D,e.size=t.k,e.useFloating=t.useFloating,Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', '../index-e9199379', 'preact/hooks', './UNSAFE_useUser', '../UNSAFE_Environment', 'preact', 'preact/jsx-runtime', '../UNSAFE_Layer', 'preact/compat', '../utils/PRIVATE_floatingUtils'], (function (exports, hooks_UNSAFE_useFloating, hooks, hooks_UNSAFE_useUser, UNSAFE_Environment, preact, jsxRuntime, UNSAFE_Layer, compat, utils_PRIVATE_floatingUtils) { 'use strict';
+
+
+
+	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;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFloating.js.map

package/amd/hooks/UNSAFE_useFloating.js.map

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

package/amd/hooks/UNSAFE_useFocus.js

@@ -1,2 +1,36 @@
-define(["exports","./UNSAFE_useToggle","preact/hooks"],function(e,s,o){"use strict";e.useFocus=function(e={isDisabled:!1}){const{bool:o,setTrue:u,setFalse:i}=s.useToggle(!1),t=e.isDisabled?{}:{onFocus:u,onBlur:i};return{isFocus:!e.isDisabled&&o,focusProps:t}},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', './UNSAFE_useToggle', 'preact/hooks'], (function (exports, hooks_UNSAFE_useToggle, hooks) { 'use strict';
+
+    /**
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFocus.js.map

package/amd/hooks/UNSAFE_useFocus.js.map

@@ -1 +1 @@
-{"version":3,"file":"UNSAFE_useFocus.js","sources":["../../../src/hooks/UNSAFE_useFocus/useFocus.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"],"names":["settings","isDisabled","bool","setTrue","setFalse","useToggle","focusProps","onFocus","onBlur","isFocus"],"mappings":"+FAUM,SAAmBA,EAAyB,CAAEC,YAAY,IAI9D,MAAMC,KAAEA,EAAIC,QAAEA,EAAOC,SAAEA,GAAaC,EAAAA,WAAU,GACxCC,EAAaN,EAASC,WACxB,GACA,CACEM,QAASJ,EACTK,OAAQJ,GAEd,MAAO,CACLK,SAAST,EAASC,YAAqBC,EACvCI,WAAYA"}
+{"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":";;;IAMA;;;IAGG;IACG,SAAU,QAAQ,CAAC,QAAA,GAAyB,EAAE,UAAU,EAAE,KAAK,EAAE,EAAA;IAIrE,IAAA,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAGA,gCAAS,CAAC,KAAK,CAAC,CAAC;IACrD,IAAA,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU;IACpC,UAAE,EAAE;IACJ,UAAE;IACE,YAAA,OAAO,EAAE,OAAO;IAChB,YAAA,MAAM,EAAE,QAAQ;aACjB,CAAC;QACN,OAAO;YACL,OAAO,EAAE,QAAQ,CAAC,UAAU,GAAG,KAAK,GAAG,IAAI;IAC3C,QAAA,UAAU,EAAE,UAAU;SACvB,CAAC;IACJ;;ICzBA;;;;;;IAMG;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useFocusWithin.js

@@ -1,2 +1,12 @@
-define(["exports","../useFocusWithin-0a53949e","preact/hooks"],function(e,s,i){"use strict";e.useFocusWithin=s.useFocusWithin,Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', '../useFocusWithin-a88e3e32', 'preact/hooks'], (function (exports, useFocusWithin, hooks) { 'use strict';
+
+
+
+	exports.useFocusWithin = useFocusWithin.useFocusWithin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFocusWithin.js.map

package/amd/hooks/UNSAFE_useFocusWithin.js.map

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

package/amd/hooks/UNSAFE_useFocusableTextField.js

@@ -1,2 +1,69 @@
-define(["exports","../tslib.es6-6a195797","preact/hooks","./UNSAFE_useFocusWithin","../useFocusWithin-0a53949e"],function(e,u,r,s,n){"use strict";e.useFocusableTextField=function(e){var{isReadonly:s,ref:o=(()=>{})}=e,t=u.__rest(e,["isReadonly","ref"]);const{focusProps:l,isFocused:c}=n.useFocusWithin(t),i=r.useRef(c),f=r.useRef(null),d=r.useRef(null);return r.useEffect(()=>{i.current&&(s?setTimeout(()=>{var e;return null===(e=d.current)||void 0===e?void 0:e.focus()}):setTimeout(()=>{var e;return null===(e=f.current)||void 0===e?void 0:e.focus()}))},[s]),r.useEffect(()=>{i.current=c},[c]),r.useImperativeHandle(o,()=>({focus:()=>{var e,u;s?null===(e=d.current)||void 0===e||e.focus():null===(u=f.current)||void 0===u||u.focus()},blur:()=>{var e,u;s?null===(e=d.current)||void 0===e||e.blur():null===(u=f.current)||void 0===u||u.blur()}}),[s]),{enabledElementRef:f,readonlyElementRef:d,isFocused:c,focusProps:l}},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', '../tslib.es6-71b1ba5b', 'preact/hooks', './UNSAFE_useFocusWithin', '../useFocusWithin-a88e3e32'], (function (exports, tslib_es6, hooks, hooks_UNSAFE_useFocusWithin, useFocusWithin) { 'use strict';
+
+    /**
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFocusableTextField.js.map

package/amd/hooks/UNSAFE_useFocusableTextField.js.map

@@ -1 +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":["_a","isReadonly","ref","useFocusWithinProps","__rest","focusProps","isFocused","useFocusWithin","previousIsFocusedRef","useRef","enabledElementRef","readonlyElementRef","useEffect","current","setTimeout","focus","useImperativeHandle","_b","blur"],"mappings":"0KA2BM,SAA8EA,GAAA,IAAAC,WAClFA,EAAUC,IACVA,EAAM,UAEqBF,EADxBG,EAAmBC,EAAAA,OAAAJ,EAH4D,sBAKlF,MAAMK,WAAEA,EAAUC,UAAEA,GAAcC,EAAcA,eAACJ,GAE3CK,EAAuBC,SAAOH,GAC9BI,EAAoBD,SAAU,MAC9BE,EAAqBF,SAAU,MA2CrC,OAxCAG,EAAAA,UAAU,KAGJJ,EAAqBK,UACnBZ,EACFa,WAAW,KAAK,IAAAd,EAAC,eAAAA,EAAAW,EAAmBE,8BAASE,UAE7CD,WAAW,KAAK,IAAAd,EAAC,eAAAA,EAAAU,EAAkBG,8BAASE,YAG/C,CAACd,IAIJW,EAAAA,UAAU,KACRJ,EAAqBK,QAAUP,GAC9B,CAACA,IAGJU,EAAmBA,oBACjBd,EACA,KAAO,CACLa,MAAO,aACDd,EAC0B,QAA5BD,EAAAW,EAAmBE,eAAS,IAAAb,GAAAA,EAAAe,QAED,QAA3BE,EAAAP,EAAkBG,eAAS,IAAAI,GAAAA,EAAAF,SAG/BG,KAAM,aACAjB,EAC0B,QAA5BD,EAAAW,EAAmBE,eAAS,IAAAb,GAAAA,EAAAkB,OAED,QAA3BD,EAAAP,EAAkBG,eAAS,IAAAI,GAAAA,EAAAC,UAIjC,CAACjB,IAGI,CACLS,kBAAAA,EACAC,mBAAAA,EACAL,UAAAA,EACAD,WAAAA"}
+{"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":";;;IAqBA;;;;;IAKG;IACG,SAAU,qBAAqB,CAA+C,EAIvD,EAAA;IAJuD,IAAA,IAAA,EAClF,UAAU,EACV,GAAG,GAAG,MAAO,GAAC,EAEa,GAAA,EAAA,EADxB,mBAAmB,GAAAA,gBAAA,CAAA,EAAA,EAH4D,qBAInF,CADuB,CAAA;QAEtB,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAGC,6BAAc,CAAC,mBAAmB,CAAC,CAAC;IAEtE,IAAA,MAAM,oBAAoB,GAAGC,YAAM,CAAC,SAAS,CAAC,CAAC;IAC/C,IAAA,MAAM,iBAAiB,GAAGA,YAAM,CAAI,IAAI,CAAC,CAAC;IAC1C,IAAA,MAAM,kBAAkB,GAAGA,YAAM,CAAI,IAAI,CAAC,CAAC;;QAG3CC,eAAS,CAAC,MAAK;;;YAGb,IAAI,oBAAoB,CAAC,OAAO,EAAE;IAChC,YAAA,IAAI,UAAU,EAAE;IACd,gBAAA,UAAU,CAAC,MAAK,EAAA,IAAA,EAAA,CAAA,CAAC,OAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,0CAAE,KAAK,EAAE,CAAA,EAAA,CAAC,CAAC;IACvD,aAAA;IAAM,iBAAA;IACL,gBAAA,UAAU,CAAC,MAAK,EAAA,IAAA,EAAA,CAAA,CAAC,OAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,0CAAE,KAAK,EAAE,CAAA,EAAA,CAAC,CAAC;IACtD,aAAA;IACF,SAAA;IACH,KAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;;;QAIjBA,eAAS,CAAC,MAAK;IACb,QAAA,oBAAoB,CAAC,OAAO,GAAG,SAAS,CAAC;IAC3C,KAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;;IAGhB,IAAAC,yBAAmB,CACjB,GAAG,EACH,OAAO;YACL,KAAK,EAAE,MAAK;;IACV,YAAA,IAAI,UAAU,EAAE;IACd,gBAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,KAAK,EAAE,CAAC;IACrC,aAAA;IAAM,iBAAA;IACL,gBAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,KAAK,EAAE,CAAC;IACpC,aAAA;aACF;YACD,IAAI,EAAE,MAAK;;IACT,YAAA,IAAI,UAAU,EAAE;IACd,gBAAA,CAAA,EAAA,GAAA,kBAAkB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAI,EAAE,CAAC;IACpC,aAAA;IAAM,iBAAA;IACL,gBAAA,CAAA,EAAA,GAAA,iBAAiB,CAAC,OAAO,MAAE,IAAA,IAAA,EAAA,KAAA,KAAA,CAAA,GAAA,KAAA,CAAA,GAAA,EAAA,CAAA,IAAI,EAAE,CAAC;IACnC,aAAA;aACF;IACF,KAAA,CAAC,EACF,CAAC,UAAU,CAAC,CACb,CAAC;QAEF,OAAO;YACL,iBAAiB;YACjB,kBAAkB;YAClB,SAAS;YACT,UAAU;SACX,CAAC;IACJ;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useFormContext.js

@@ -1,2 +1,39 @@
-define(["exports","preact","preact/hooks"],function(e,t,s){"use strict";const n={isDisabled:!1,isFormLayout:!1,isReadonly:!1,labelEdge:"inside",labelStartWidth:"33%",labelWrapping:"wrap",textAlign:"start",userAssistanceDensity:"reflow"},o=t.createContext(n);e.FormContext=o,e.useFormContext=function(){const e=s.useContext(o);return Object.assign({},n,e)},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact', 'preact/hooks'], (function (exports, preact, hooks) { 'use strict';
+
+    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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFormContext.js.map

package/amd/hooks/UNSAFE_useFormContext.js.map

@@ -1 +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":["DefaultFormContext","isDisabled","isFormLayout","isReadonly","labelEdge","labelStartWidth","labelWrapping","textAlign","userAssistanceDensity","FormContext","createContext","context","useContext","Object","assign"],"mappings":"wEA2CA,MAAMA,EAAuC,CAC3CC,YAAY,EACZC,cAAc,EACdC,YAAY,EACZC,UAAW,SACXC,gBAAiB,MACjBC,cAAe,OACfC,UAAW,QACXC,sBAAuB,UAOnBC,EAAcC,EAAaA,cAAmBV,oCClDpD,WACE,MAAMW,EAAUC,aAAWH,GAG3B,OAD4BI,OAAOC,OAAO,GAAId,EAAoBW"}
+{"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":";;;IA2CA,MAAM,kBAAkB,GAAqB;IAC3C,IAAA,UAAU,EAAE,KAAK;IACjB,IAAA,YAAY,EAAE,KAAK;IACnB,IAAA,UAAU,EAAE,KAAK;IACjB,IAAA,SAAS,EAAE,QAAQ;IACnB,IAAA,eAAe,EAAE,KAAK;IACtB,IAAA,aAAa,EAAE,MAAM;IACrB,IAAA,SAAS,EAAE,OAAO;IAClB,IAAA,qBAAqB,EAAE,QAAQ;KAChC,CAAC;IAEF;;;IAGG;AACH,UAAM,WAAW,GAAGA,oBAAa,CAAmB,kBAAkB;;ICvDtE;;;;IAIG;IACH,SAAS,cAAc,GAAA;IACrB,IAAA,MAAM,OAAO,GAAGC,gBAAU,CAAC,WAAW,CAAC,CAAC;;IAExC,IAAA,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,kBAAkB,EAAE,OAAO,CAAC,CAAC;IAC3E,IAAA,OAAO,mBAAmB,CAAC;IAC7B;;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useFormFieldContext.js

@@ -1,2 +1,32 @@
-define(["exports","preact","preact/hooks"],function(e,t,o){"use strict";const s=t.createContext({hasValue:!1,isDisabled:!1,isFocused:!1,isLoading:!1,isReadonly:!1});e.FormFieldContext=s,e.useFormFieldContext=function(){return o.useContext(s)},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact', 'preact/hooks'], (function (exports, preact, hooks) { 'use strict';
+
+    /**
+     * 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;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFormFieldContext.js.map

package/amd/hooks/UNSAFE_useFormFieldContext.js.map

@@ -1 +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":["FormFieldContext","createContext","hasValue","isDisabled","isFocused","isLoading","isReadonly","useContext"],"mappings":"wEAgFM,MAAAA,EAAmBC,EAAAA,cAAqC,CAC5DC,UAAU,EACVC,YAAY,EACZC,WAAW,EACXC,WAAW,EACXC,YAAY,+CC7Ed,WACE,OAAOC,EAAAA,WAAWP"}
+{"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":";;;IA4EA;;;IAGG;AACG,UAAA,gBAAgB,GAAGA,oBAAa,CAAwB;IAC5D,IAAA,QAAQ,EAAE,KAAK;IACf,IAAA,UAAU,EAAE,KAAK;IACjB,IAAA,SAAS,EAAE,KAAK;IAChB,IAAA,SAAS,EAAE,KAAK;IAChB,IAAA,UAAU,EAAE,KAAK;IAClB,CAAA;;ICnFD;;;;IAIG;IACH,SAAS,mBAAmB,GAAA;IAC1B,IAAA,OAAOC,gBAAU,CAAC,gBAAgB,CAAC,CAAC;IACtC;;;;;;;;;;;;;;"}

package/amd/hooks/UNSAFE_useFormVariantContext.js

@@ -1,2 +1,26 @@
-define(["exports","preact","preact/hooks"],function(e,t,n){"use strict";const o=t.createContext("default");e.FormVariantContext=o,e.useFormVariantContext=function(){return n.useContext(o)},Object.defineProperty(e,"__esModule",{value:!0})});
+/* @oracle/oraclejet-preact: 14.0.7 */
+define(['exports', 'preact', 'preact/hooks'], (function (exports, preact, hooks) { 'use strict';
+
+    /**
+     * Context which an ancestor component can use to provide a value for the 'variant' property
+     * of the descendant form fields.
+     */
+    const FormVariantContext = preact.createContext('default');
+
+    /**
+     * Utility hook for consuming the FormVariantContext
+     *
+     * @returns The value of the closest FormVariantContext provider
+     */
+    function useFormVariantContext() {
+        return hooks.useContext(FormVariantContext);
+    }
+
+    exports.FormVariantContext = FormVariantContext;
+    exports.useFormVariantContext = useFormVariantContext;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+/*  */
 //# sourceMappingURL=UNSAFE_useFormVariantContext.js.map