@oracle/oraclejet-preact 14.0.0

package/amd/hooks/PRIVATE_useMessagesFocusManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PRIVATE_useMessagesFocusManager.js","sources":["../../../src/hooks/PRIVATE_useMessagesFocusManager/useMessagesFocusManager.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { RefObject } from 'preact';\nimport { useEffect, useMemo, useRef, useState } from 'preact/hooks';\nimport { HTMLAttributesSignalExcluded } from '../../utils/UNSAFE_attributeUtils';\n\nexport type FocusableComponentHandle = {\n  focus: () => boolean;\n  contains: (element: HTMLElement) => boolean;\n};\n\ntype FocusableComponentCallbacks = {\n  onFocus?: () => void;\n  onFocusLeave?: () => void;\n};\n\ntype FocusManagerHandlers = Pick<\n  HTMLAttributesSignalExcluded,\n  'onfocusin' | 'onfocusout' | 'onKeyUp'\n>;\n\ntype ComponentOptions = {\n  ref: RefObject<FocusableComponentHandle>;\n  callbacks?: FocusableComponentCallbacks;\n};\n\ntype FocusManagerOptions = {\n  handleEscapeKey?: boolean;\n};\n\nconst componentsMap = new Map<symbol, ComponentOptions>();\nconst componentsOrder = [] as symbol[];\nconst priorFocusCache = new Map<symbol, Node>();\nlet hasDocumentListener = false;\nlet priorFocusedElement: HTMLElement;\nlet currentFocusedMessage: symbol | undefined;\n\n/**\n * Handles KeyDown event in the document element during the capture phase.\n *\n * @param event The keydown event object\n */\nfunction handleDocumentKeyDownCapture(event: KeyboardEvent) {\n  // Do nothing if any of the following is true:\n  // 1. No components are registered\n  // 2. Pressed key is not F6\n  // 3. Event is defaultPrevented\n  if (componentsMap.size === 0 || event.key !== 'F6' || event.defaultPrevented) {\n    return;\n  }\n\n  // Try cycling focus through the messages and if that fails\n  // set the focus to the prior focused element.\n  if (!cycleFocusThroughMessages(event)) {\n    currentFocusedMessage && togglePreviousFocus(currentFocusedMessage, event);\n  }\n}\n\n/**\n * Handles the blur event captured on the document\n * @param event Blur event object\n */\nfunction handleDocumentBlurCapture(event: FocusEvent) {\n  priorFocusedElement = event.target as HTMLElement;\n}\n\n/**\n * Handles the keyup event in the component\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param event The keyup event object\n */\nfunction handleComponentKeyUp(id: symbol, event: KeyboardEvent) {\n  // Ignore the call if the comp is not registered anymore or event default is prevented\n  if (!componentsMap.has(id) || event.defaultPrevented) {\n    return;\n  }\n\n  // Additional checks for keyup event and recognized keys\n  if (event.type === 'keyup' && ['Escape'].includes(event.key)) {\n    // toggle focus to the previously focused element\n    togglePreviousFocus(id, event);\n  }\n}\n\n/**\n * Handles the focus event in the component\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param event The focus event object\n */\nfunction handleComponentFocus(id: symbol, event: FocusEvent) {\n  // Ignore the call if the comp is not registered anymore or event default is prevented\n  if (!componentsMap.has(id) || event.defaultPrevented) {\n    return;\n  }\n\n  // Store the id of the current focused message\n  currentFocusedMessage = id;\n\n  // Track previous focus if the priorFocused element is not a part of this or any other\n  // registered component\n  const { callbacks } = componentsMap.get(id)!;\n  if (priorFocusedElement && !isPartOfRegisteredMessages(priorFocusedElement)) {\n    priorFocusCache.set(id, priorFocusedElement!);\n\n    // since the focus moved to this component from outside, call the\n    // onFocus callbacks if available\n    callbacks?.onFocus?.();\n  }\n}\n\n/**\n * Handles the blur event in the component\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param event The focus event object\n */\nfunction handleComponentBlur(id: symbol, event: FocusEvent) {\n  // Ignore the call if the comp is not registered anymore or event default is prevented\n  if (!componentsMap.has(id) || event.defaultPrevented) {\n    return;\n  }\n\n  // reset the current focus message ID\n  currentFocusedMessage = undefined;\n}\n\n/**\n * Cycles the focus through the registered messages component from the previous message of current focused\n * message to the top of the hierarchy.\n *\n * @param event The event that initiated this action\n * @returns boolean indicating the result of this action\n */\nfunction cycleFocusThroughMessages(event: Event) {\n  // At this point, we need to focus the previous message from the current focused\n  // message\n  const nextPosition =\n    indexOfOrDefaultTo(componentsOrder, currentFocusedMessage, componentsOrder.length) - 1;\n  for (let i = nextPosition; i > -1; i--) {\n    const id = componentsOrder[i];\n    const { ref } = componentsMap.get(id) ?? {};\n    if (ref?.current?.focus?.()) {\n      // prevent default action as the event has transferred focus\n      event.preventDefault();\n      // invoke callback to let the current component know the focus is left\n      if (currentFocusedMessage) {\n        const { callbacks } = componentsMap.get(currentFocusedMessage) ?? {};\n        callbacks?.onFocusLeave?.();\n      }\n      // Focus is set, so break the loop\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Checks if the provided element is a part of any of the registered messages\n *\n * @param element The candidate element\n * @returns true if is inside any of the registered messages\n */\nfunction isPartOfRegisteredMessages(element: HTMLElement) {\n  for (const { ref } of componentsMap.values()) {\n    if (ref.current?.contains(element)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Finds the index of the item in the array, if it does not exist returns the\n * default value instead\n *\n * @param arr The array to perform the search\n * @param search The item to be searched\n * @param defaultIndex The default value if the item is not found\n * @returns The index of the item or the default value\n */\nfunction indexOfOrDefaultTo<T>(arr: T[], search: T, defaultIndex = -1) {\n  const index = arr.indexOf(search);\n  if (index !== -1) return index;\n  return defaultIndex;\n}\n\n/**\n * Traverses through the priorFocusCache to fetch the last focused\n * element outside of the messages region.\n *\n * @param id The current focused message's ID\n * @returns The closest prior focused element, null if not found\n */\nfunction getClosestPriorFocusedElement(id: symbol) {\n  // F6 navigation cycles through messages in reverse order\n  // so to get the closest prior focused element we need to\n  // traverse in natural order from the current message\n  const index = componentsOrder.indexOf(id);\n  for (let i = index; i < componentsOrder.length; i++) {\n    if (priorFocusCache.has(componentsOrder[i])) {\n      return priorFocusCache.get(componentsOrder[i])!;\n    }\n  }\n\n  // No prior cache found, so return null\n  return null;\n}\n\n/**\n * Adds the component to the internal members.\n *\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param ref A ref handle to the focusable component\n * @param callbacks Optional callbacks\n */\nfunction addComponent(id: symbol, options: ComponentOptions) {\n  componentsMap.set(id, options);\n  componentsOrder.push(id);\n}\n\n/**\n * Removes the component from the internal members\n *\n * @param id A unique symbol that ids the component to be registered for managing focus\n */\nfunction removeComponent(id: symbol) {\n  if (!componentsMap.has(id)) {\n    return;\n  }\n\n  componentsMap.delete(id);\n  componentsOrder.splice(componentsOrder.indexOf(id), 1);\n}\n\n/**\n * Clears the priorFocusCache of the specified component\n *\n * @param id The id of the component whose cache is to be cleared\n */\nfunction clearFocusCache(id: symbol) {\n  priorFocusCache.delete(id);\n}\n\n/**\n * Adds event listeners to the document element\n */\nfunction addDocumentListeners() {\n  // Add the events in capture phase, as we do not want this to be stopped by the elements\n  // in the DOM tree.\n  // make sure to use keydown as we need to prevent the default behavior which is moving to\n  // the address bar in some browsers & OS.\n  document.documentElement.addEventListener('keydown', handleDocumentKeyDownCapture, true);\n  document.documentElement.addEventListener('blur', handleDocumentBlurCapture, true);\n  hasDocumentListener = true;\n}\n\n/**\n * Removes event listeners from the document element\n */\nfunction removeDocumentListeners() {\n  document.documentElement.removeEventListener('keydown', handleDocumentKeyDownCapture, true);\n  document.documentElement.removeEventListener('blur', handleDocumentBlurCapture, true);\n  hasDocumentListener = false;\n}\n\n/**\n * Registers a component for its focus to be managed.\n *\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param componentOptions An object containing component options\n * @param focusManagerOptions An object containing focus manager options\n *\n * @returns An object containing focus event listeners\n */\nfunction register(\n  id: symbol,\n  componentOptions: ComponentOptions,\n  focusManagerOptions: FocusManagerOptions = { handleEscapeKey: true }\n) {\n  if (!hasDocumentListener) {\n    addDocumentListeners();\n  }\n\n  addComponent(id, componentOptions);\n  const handlers: FocusManagerHandlers = {\n    onfocusin: (event: FocusEvent) => handleComponentFocus(id, event),\n    onfocusout: (event: FocusEvent) => handleComponentBlur(id, event)\n  };\n  if (focusManagerOptions.handleEscapeKey) {\n    handlers['onKeyUp'] = (event: KeyboardEvent) => handleComponentKeyUp(id, event);\n  }\n  return handlers;\n}\n\n/**\n * Focuses the element which was focused prior to the passed component.\n * @param id A unique symbol that ids the component to be registered for managing focus\n * @param event The event that initiated the focus transfer. The event will be default prevented if the focus\n *              is transferred successfully.\n * @returns true, if focus is restored. false otherwise.\n */\nfunction togglePreviousFocus(id: symbol, event?: Event) {\n  const target = getClosestPriorFocusedElement(id);\n  const { callbacks } = componentsMap.get(id) ?? {};\n  if (target && document.body.contains(target)) {\n    (target as HTMLElement).focus();\n    // invoke callback to let the component know the focus is left\n    callbacks?.onFocusLeave?.();\n    // As the prior focus is restored, empty the focus cache\n    priorFocusCache.clear();\n    event?.preventDefault();\n    return true;\n  }\n\n  // Prior focused element does not exist or\n  // Element does not exist in DOM.\n  return false;\n}\n\n/**\n * Unregisters a component from focus management\n *\n * @param id A unique symbol that ids the component to be registered for managing focus\n */\nfunction unregister(id: symbol) {\n  removeComponent(id);\n  clearFocusCache(id);\n\n  if (hasDocumentListener && componentsMap.size === 0) {\n    // no component is registered, so remove the document listeners\n    removeDocumentListeners();\n  }\n}\n\n/**\n * Moves the priority of the component with the specified id\n *\n * @param id A unique symbol that ids the component to be registered for managing focus\n */\nfunction prioritize(id: symbol) {\n  if (!componentsMap.has(id)) {\n    // Do nothing if the component is not registered\n    return;\n  }\n\n  // Remove and add the component with the same ref\n  // to move it in the priority queue\n  const options = componentsMap.get(id)!;\n  removeComponent(id);\n  addComponent(id, options);\n}\n\n/**\n * The focus manager object\n */\nconst messagesFocusManager = {\n  prioritize,\n  register,\n  togglePreviousFocus,\n  unregister\n};\n\n/**\n * A custom hook that handles focus management for the messages component.\n * @param ref The custom ref handle for the component\n * @param callbacks Optional callbacks\n * @returns The handlers and a controller\n */\nexport function useMessageFocusManager(\n  ref: ComponentOptions['ref'],\n  callbacks?: ComponentOptions['callbacks'],\n  options?: FocusManagerOptions\n) {\n  const id = useRef(Symbol());\n  const focusManager = useRef(messagesFocusManager);\n  const [handlers, setHandlers] = useState<FocusManagerHandlers>({});\n  const controller = useMemo(\n    () => ({\n      prioritize: () => focusManager.current.prioritize(id.current),\n      restorePriorFocus: () => focusManager.current.togglePreviousFocus(id.current)\n    }),\n    []\n  );\n\n  // Register handlers for focus management\n  useEffect(() => {\n    const currentFocusManager = focusManager.current;\n    const currentId = id.current;\n    setHandlers(currentFocusManager.register(currentId, { ref, callbacks }, options));\n    return () => currentFocusManager.unregister(currentId);\n    // eslint-disable-next-line\n  }, []); // we only want this to run on mount\n\n  return {\n    handlers,\n    controller\n  };\n}\n"],"names":["componentsMap","Map","componentsOrder","priorFocusCache","priorFocusedElement","currentFocusedMessage","hasDocumentListener","handleDocumentKeyDownCapture","event","size","key","defaultPrevented","i","arr","search","defaultIndex","index","indexOf","indexOfOrDefaultTo","length","id","ref","_a","get","_c","_b","current","focus","call","preventDefault","callbacks","_d","_e","onFocusLeave","cycleFocusThroughMessages","togglePreviousFocus","handleDocumentBlurCapture","target","handleComponentFocus","has","element","values","contains","isPartOfRegisteredMessages","set","onFocus","addComponent","options","push","removeComponent","delete","splice","getClosestPriorFocusedElement","document","body","clear","messagesFocusManager","prioritize","register","componentOptions","focusManagerOptions","handleEscapeKey","documentElement","addEventListener","handlers","onfocusin","onfocusout","undefined","handleComponentBlur","type","includes","handleComponentKeyUp","unregister","clearFocusCache","removeEventListener","useRef","Symbol","focusManager","setHandlers","useState","controller","useMemo","restorePriorFocus","useEffect","currentFocusManager","currentId"],"mappings":"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"}

package/amd/hooks/PRIVATE_useSelection.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../utils/UNSAFE_arrayUtils","../utils/UNSAFE_keys"],(function(e,t,r,n){"use strict";r.stringLiteralArray(["toggle","replace"]);const l=(e,t,r,l,o,s,i,a,y,u)=>{const c=t(e.target);if(null==c)return;if(e.shiftKey&&void 0!==a&&u&&((e,t,r,l)=>"multiple"===r&&"toggle"!==l&&n.containsKey(t,e))(a,r,l,o))return u({value:{start:a,end:c}}),void(i&&(i.current=c));let k=r;n.containsKey(r,c)?"Enter"!==e.key&&("toggle"===o||e.ctrlKey||e.metaKey||" "===e.key?k=n.removeKey(r,c,s):"multiple"===l&&(r.all||r.keys.size>1)&&(k={all:!1,keys:new Set([c])})):k="single"===l||"Enter"===e.key||"replace"===o&&!e.ctrlKey&&!e.metaKey?{all:!1,keys:new Set([c])}:n.addKey(r,c),r!=k&&y&&(y({value:k,target:e.target}),"click"===e.type&&e.stopPropagation())};e.useSelection=function(e,r,o,s,i,a,y,u,c,k,K){const f=t.useRef(),d=t.useCallback((t=>{l(t,e,r,o,i,s,f,y,a,K),t.shiftKey||(f.current=void 0)}),[e,r,o,i,s,f,y,a,K]),g=t.useCallback((t=>{" "!==t.key&&"Enter"!==t.key||l(t,e,r,o,i,s,f,y,a,t.shiftKey&&" "===t.key?K:void 0)}),[e,r,o,i,s,y,a,K]),p=t.useCallback((e=>{if(" "!==e.key){if("ArrowDown"===e.key||"ArrowUp"===e.key)if(e.shiftKey&&c&&k){let t=r;!f.current&&n.isKeyDefined(u)&&(t={all:!1,keys:new Set([u])});const l=c(f.current||u,"ArrowDown"!==e.key)();null!=l&&(n.containsKey(t,l)?null!=f.current&&f.current!==l&&(t=n.removeKey(t,f.current,s)):t=n.addKey(t,l),f.current=l,k(l)),r!=t&&a&&a({value:t,target:e.target})}else f.current=void 0}else e.preventDefault()}),[r,s,a,u,c,k]);return{selectionProps:"none"===o||null==a?{}:{onClick:d,onKeyDown:p,onKeyUp:g}}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=PRIVATE_useSelection.js.map

package/amd/hooks/PRIVATE_useSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PRIVATE_useSelection.js","sources":["../../../src/hooks/PRIVATE_useSelection/useSelection.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 { RefObject } from 'preact';\nimport { useCallback, useRef } from 'preact/hooks';\nimport { stringLiteralArray } from '../../utils/UNSAFE_arrayUtils';\nimport { Keys, containsKey, isKeyDefined, addKey, removeKey } from '../../utils/UNSAFE_keys';\nimport { SelectionDetail, SelectionMode } from '../../UNSAFE_Collection';\n\n/**\n * Type for selection behavior.  See useMultipleSelection hook for details.\n */\nexport const behaviors = stringLiteralArray(['toggle', 'replace']);\nexport type SelectionBehavior = typeof behaviors[number];\n\n/**\n * Type for payload of selection range change event handler\n */\nexport type SelectionRangeDetail<K> = {\n  value: { start: K; end: K };\n};\n\nconst isShiftModeSupported = <K>(\n  anchorKey: K,\n  selectedKeys: Keys<K>,\n  selectionMode: SelectionMode,\n  selectionBehavior: SelectionBehavior\n) => {\n  return (\n    selectionMode === 'multiple' &&\n    selectionBehavior !== 'toggle' &&\n    containsKey(selectedKeys, anchorKey)\n  );\n};\n\nconst handleSelect = <K>(\n  event: MouseEvent | KeyboardEvent,\n  keyExtractor: (element: HTMLElement) => K | null,\n  selectedKeys: Keys<K>,\n  selectionMode: SelectionMode,\n  selectionBehavior: SelectionBehavior,\n  isSelectionRequired: boolean,\n  keyboardCursorRef: RefObject<K | undefined>,\n  anchorKey?: K,\n  onChange?: (detail: SelectionDetail<K>) => void,\n  onRangeChange?: (detail: SelectionRangeDetail<K>) => void\n) => {\n  const itemKey = keyExtractor(event.target as HTMLElement);\n  if (itemKey == null) {\n    return;\n  }\n\n  // handle shift key selection\n  if (\n    event.shiftKey &&\n    anchorKey !== undefined &&\n    onRangeChange &&\n    isShiftModeSupported(anchorKey, selectedKeys, selectionMode, selectionBehavior)\n  ) {\n    onRangeChange({ value: { start: anchorKey, end: itemKey } });\n    // set keyboard selection cursor in case user extends with SHIFT+ARROW\n    if (keyboardCursorRef) {\n      keyboardCursorRef.current = itemKey;\n    }\n    return;\n  }\n\n  const selected = containsKey(selectedKeys, itemKey);\n  let keySet = selectedKeys;\n  if (!selected) {\n    if (\n      selectionMode === 'single' ||\n      (event as KeyboardEvent).key === 'Enter' ||\n      (selectionBehavior === 'replace' && !(event.ctrlKey || event.metaKey))\n    ) {\n      // should only contains this item key\n      keySet = { all: false, keys: new Set([itemKey]) };\n    } else {\n      // add to existing selected keys\n      keySet = addKey(selectedKeys, itemKey);\n    }\n  } else if ((event as KeyboardEvent).key !== 'Enter') {\n    // no de-select for enter key\n    if (\n      selectionBehavior === 'toggle' ||\n      event.ctrlKey ||\n      event.metaKey ||\n      (event as KeyboardEvent).key === ' '\n    ) {\n      // de-select only when ctrl/meta key is pressed or selectionBehavior is\n      // explicitly set to toggle\n      keySet = removeKey(selectedKeys, itemKey, isSelectionRequired);\n    } else if (selectionMode === 'multiple' && (selectedKeys.all || selectedKeys.keys.size > 1)) {\n      // in this case everything should be de-selected except for this key\n      keySet = { all: false, keys: new Set([itemKey]) };\n    }\n  }\n\n  // only invoke callback if there is really a change\n  // note onSelectionChange should never be null here\n  if (selectedKeys != keySet && onChange) {\n    onChange({ value: keySet, target: event.target });\n    if (event.type === 'click') {\n      event.stopPropagation();\n    }\n  }\n};\n\n/**\n * Hook for handling various selection mode.  This can be reuse by all Collection components.\n * @param keyExtractor function to extract the key based on provided element\n * @param selectedKeys the currently selected keys\n * @param selectionMode the selection mode\n * @param selectionBehavior the selection behavior.  If the value is 'toggle', then the key is\n *                          added/removed from the current selected keys.  If the value is 'replace',\n *                          then the current selected keys are cleared first before the key is added\n *                          unless the ctrl/shift/meta key is pressed.\n * @param onSelectionChange callback function that is invoked when selection has changed.\n * @returns an event map that the consumer can register as event listeners\n */\nexport function useSelection<K>(\n  keyExtractor: (element: HTMLElement) => K | null,\n  selectedKeys: Keys<K>,\n  selectionMode: SelectionMode,\n  isSelectionRequired: boolean,\n  selectionBehavior: SelectionBehavior,\n  onChange?: (detail: SelectionDetail<K>) => void,\n  anchorKey?: K,\n  currentKey?: K | undefined,\n  getPrevNextKey?: (currentKey: K | undefined, isPrev: boolean) => () => K | null,\n  scrollToKey?: (key: K) => void,\n  onRangeChange?: (detail: SelectionRangeDetail<K>) => void\n) {\n  // ref to track the cursor for the SHIFT+ARROW keyboard selection separately than the anchor of the selection.\n  const keyboardSelectionCursor = useRef<K>();\n\n  const onClick = useCallback(\n    (event: MouseEvent) => {\n      handleSelect(\n        event,\n        keyExtractor,\n        selectedKeys,\n        selectionMode,\n        selectionBehavior,\n        isSelectionRequired,\n        keyboardSelectionCursor,\n        anchorKey,\n        onChange,\n        onRangeChange\n      );\n      if (!event.shiftKey) {\n        // reset keyboard cursor when using mouse to select\n        keyboardSelectionCursor.current = undefined;\n      }\n    },\n    [\n      keyExtractor,\n      selectedKeys,\n      selectionMode,\n      selectionBehavior,\n      isSelectionRequired,\n      keyboardSelectionCursor,\n      anchorKey,\n      onChange,\n      onRangeChange\n    ]\n  );\n\n  // general keyboard events listen to keyUp for a11y\n  const onKeyUp = useCallback(\n    (event: KeyboardEvent) => {\n      // older browser that we don't support returns 'Spacebar' for space key\n      if (event.key === ' ' || event.key === 'Enter') {\n        handleSelect(\n          event,\n          keyExtractor,\n          selectedKeys,\n          selectionMode,\n          selectionBehavior,\n          isSelectionRequired,\n          keyboardSelectionCursor,\n          anchorKey,\n          onChange,\n          event.shiftKey && event.key === ' ' ? onRangeChange : undefined\n        );\n      }\n    },\n    [\n      keyExtractor,\n      selectedKeys,\n      selectionMode,\n      selectionBehavior,\n      isSelectionRequired,\n      anchorKey,\n      onChange,\n      onRangeChange\n    ]\n  );\n\n  // arrowKey events listen to keyDown so they can support holding them down\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      // prevent default (propagation) for keyDown to space bar causing container to scroll\n      if (event.key === ' ') {\n        event.preventDefault();\n        return;\n      }\n\n      if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {\n        if (event.shiftKey && getPrevNextKey && scrollToKey) {\n          let keySet = selectedKeys;\n          // on first selection event, set keyboard cursor to start at currentKey\n          if (!keyboardSelectionCursor.current && isKeyDefined(currentKey)) {\n            keySet = { all: false, keys: new Set([currentKey as K]) };\n          }\n          const newAnchorKey = getPrevNextKey(\n            keyboardSelectionCursor.current || currentKey,\n            event.key === 'ArrowDown' ? false : true\n          );\n          const cursorKey = newAnchorKey();\n          if (cursorKey != null) {\n            // extend selection\n            if (!containsKey(keySet, cursorKey)) {\n              keySet = addKey(keySet, cursorKey);\n              // subtract from selection\n            } else if (\n              keyboardSelectionCursor.current != null &&\n              keyboardSelectionCursor.current !== cursorKey\n            ) {\n              keySet = removeKey(keySet, keyboardSelectionCursor.current, isSelectionRequired);\n            }\n            keyboardSelectionCursor.current = cursorKey;\n            // keep visible\n            scrollToKey(cursorKey);\n          }\n          if (selectedKeys != keySet && onChange) {\n            onChange({ value: keySet, target: event.target });\n          }\n        } else {\n          // reset keyBoard on non-shifted arrow use as this interrupts the extend mode (and would make for messy logic that doesn't align with current Jet behavior)\n          keyboardSelectionCursor.current = undefined;\n        }\n      }\n    },\n    [selectedKeys, isSelectionRequired, onChange, currentKey, getPrevNextKey, scrollToKey]\n  );\n\n  const selectionProps =\n    selectionMode === 'none' || onChange == null ? {} : { onClick, onKeyDown, onKeyUp };\n  return { selectionProps };\n}\n"],"names":["stringLiteralArray","handleSelect","event","keyExtractor","selectedKeys","selectionMode","selectionBehavior","isSelectionRequired","keyboardCursorRef","anchorKey","onChange","onRangeChange","itemKey","target","shiftKey","undefined","containsKey","isShiftModeSupported","value","start","end","current","keySet","key","ctrlKey","metaKey","removeKey","all","keys","size","Set","addKey","type","stopPropagation","currentKey","getPrevNextKey","scrollToKey","keyboardSelectionCursor","useRef","onClick","useCallback","onKeyUp","onKeyDown","isKeyDefined","cursorKey","newAnchorKey","preventDefault","selectionProps"],"mappings":"sHAgByBA,EAAAA,mBAAmB,CAAC,SAAU,YAAhD,MAuBDC,EAAe,CACnBC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,KAEA,MAAMC,EAAUT,EAAaD,EAAMW,QACnC,GAAe,MAAXD,EACF,OAIF,GACEV,EAAMY,eACQC,IAAdN,GACAE,GAlCyB,EAC3BF,EACAL,EACAC,EACAC,IAGoB,aAAlBD,GACsB,WAAtBC,GACAU,cAAYZ,EAAcK,GA0B1BQ,CAAqBR,EAAWL,EAAcC,EAAeC,GAO7D,OALAK,EAAc,CAAEO,MAAO,CAAEC,MAAOV,EAAWW,IAAKR,UAE5CJ,IACFA,EAAkBa,QAAUT,IAMhC,IAAIU,EAASlB,EADIY,EAAAA,YAAYZ,EAAcQ,GAcC,UAAhCV,EAAwBqB,MAGV,WAAtBjB,GACAJ,EAAMsB,SACNtB,EAAMuB,SAC2B,MAAhCvB,EAAwBqB,IAIzBD,EAASI,EAAAA,UAAUtB,EAAcQ,EAASL,GACf,aAAlBF,IAAiCD,EAAauB,KAAOvB,EAAawB,KAAKC,KAAO,KAEvFP,EAAS,CAAEK,KAAK,EAAOC,KAAM,IAAIE,IAAI,CAAClB,OAlBtCU,EALkB,WAAlBjB,GACiC,UAAhCH,EAAwBqB,KACF,YAAtBjB,IAAqCJ,EAAMsB,UAAWtB,EAAMuB,QAGpD,CAAEE,KAAK,EAAOC,KAAM,IAAIE,IAAI,CAAClB,KAG7BmB,EAAMA,OAAC3B,EAAcQ,GAqB9BR,GAAgBkB,GAAUZ,IAC5BA,EAAS,CAAEQ,MAAOI,EAAQT,OAAQX,EAAMW,SACrB,UAAfX,EAAM8B,MACR9B,EAAM+B,mCAiBN,SACJ9B,EACAC,EACAC,EACAE,EACAD,EACAI,EACAD,EACAyB,EACAC,EACAC,EACAzB,GAGA,MAAM0B,EAA0BC,EAAAA,SAE1BC,EAAUC,eACbtC,IACCD,EACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EACA8B,EACA5B,EACAC,EACAC,GAEGT,EAAMY,WAETuB,EAAwBhB,aAAUN,KAGtC,CACEZ,EACAC,EACAC,EACAC,EACAC,EACA8B,EACA5B,EACAC,EACAC,IAKE8B,EAAUD,eACbtC,IAEmB,MAAdA,EAAMqB,KAA6B,UAAdrB,EAAMqB,KAC7BtB,EACEC,EACAC,EACAC,EACAC,EACAC,EACAC,EACA8B,EACA5B,EACAC,EACAR,EAAMY,UAA0B,MAAdZ,EAAMqB,IAAcZ,OAAgBI,KAI5D,CACEZ,EACAC,EACAC,EACAC,EACAC,EACAE,EACAC,EACAC,IAKE+B,EAAYF,eACftC,IAEC,GAAkB,MAAdA,EAAMqB,KAKV,GAAkB,cAAdrB,EAAMqB,KAAqC,YAAdrB,EAAMqB,IACrC,GAAIrB,EAAMY,UAAYqB,GAAkBC,EAAa,CACnD,IAAId,EAASlB,GAERiC,EAAwBhB,SAAWsB,EAAYA,aAACT,KACnDZ,EAAS,CAAEK,KAAK,EAAOC,KAAM,IAAIE,IAAI,CAACI,MAExC,MAIMU,EAJeT,EACnBE,EAAwBhB,SAAWa,EACrB,cAAdhC,EAAMqB,IAEUsB,GACD,MAAbD,IAEG5B,EAAWA,YAACM,EAAQsB,GAIY,MAAnCP,EAAwBhB,SACxBgB,EAAwBhB,UAAYuB,IAEpCtB,EAASI,EAASA,UAACJ,EAAQe,EAAwBhB,QAASd,IAN5De,EAASS,EAAMA,OAACT,EAAQsB,GAQ1BP,EAAwBhB,QAAUuB,EAElCR,EAAYQ,IAEVxC,GAAgBkB,GAAUZ,GAC5BA,EAAS,CAAEQ,MAAOI,EAAQT,OAAQX,EAAMW,cAI1CwB,EAAwBhB,aAAUN,OApCpCb,EAAM4C,mBAwCV,CAAC1C,EAAcG,EAAqBG,EAAUwB,EAAYC,EAAgBC,IAK5E,MAAO,CAAEW,eADW,SAAlB1C,GAAwC,MAAZK,EAAmB,GAAK,CAAE6B,QAAAA,EAASG,UAAAA,EAAWD,QAAAA"}

package/amd/hooks/PRIVATE_useSingleSelection.js

@@ -0,0 +1,2 @@
+define(["exports","../useSingleSelection-089373da","preact/hooks"],(function(e,i,n){"use strict";e.useSingleSelection=i.useSingleSelection,Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=PRIVATE_useSingleSelection.js.map

package/amd/hooks/PRIVATE_useSingleSelection.js.map

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

package/amd/hooks/PRIVATE_useTabbableModeSet.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../utils/UNSAFE_keys"],(function(e,t,a){"use strict";e.useTabbableModeSet=function(e,o,r,s,n){const[l,c]=t.useState(),u=t.useCallback(((e,t=!1)=>{c(void 0),s&&s(e,t)}),[s,c]),i=t.useCallback((e=>{c(e),n&&n(e)}),[n,c]),d=t.useCallback((e=>e===l),[l]),k={onFocus:e=>{const t=o(e.target);a.isKeyDefined(t)&&!d(t)&&i(t)},onBlur:t=>{t.relatedTarget&&e(t.relatedTarget)||u(t.relatedTarget)},onKeyUp:t.useCallback((e=>{"F2"===e.key&&(void 0===r||d(r)?u(e.target,!0):i(r)),"Esc"!==e.key&&"Escape"!==e.key||u(e.target,!0)}),[r,u,i,d]),onPointerDown:e=>{const t=o(e.target);void 0===l||d(t)||u(e.target)}};return[d,k]},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=PRIVATE_useTabbableModeSet.js.map

package/amd/hooks/PRIVATE_useTabbableModeSet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PRIVATE_useTabbableModeSet.js","sources":["../../../src/hooks/PRIVATE_useTabbableModeSet/useTabbableModeSet.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 { useCallback, useState } from 'preact/hooks';\nimport { isKeyDefined } from '../../utils/UNSAFE_keys';\n\n/**\n * Hook for handling Tabbable mode set provider components.\n *\n * @param contains - callback to check  whether an element is in set\n * @param keyExtractor - function to extract the key based on provided element\n * @param currentKey - current key navigation \"cursor\" is on\n * @param onTabbableModeDisable - callback to parent when set is disabled\n * @param onTabbableModeEnable - callback to parent when set is enabled\n * @returns isCurrentTabbableKey - callback for parent to check if key is in interactive mode\n * @returns tabbableSetProps - event handlers mode relies on\n */\nexport function useTabbableModeSet<K>(\n  contains: (elem: Element | null) => boolean,\n  keyExtractor: (element: HTMLElement) => K | null,\n  currentKey?: K,\n  onTabbableModeDisable?: (target: EventTarget | null, isKeyboardEvent: boolean) => void,\n  onTabbableModeEnable?: (key: K) => void\n): [\n  (key?: K) => boolean,\n  {\n    onFocus: (event: FocusEvent) => void;\n    onBlur: (event: FocusEvent) => void;\n    onKeyUp: (event: KeyboardEvent) => void;\n    onPointerDown: (event: MouseEvent) => void;\n  }\n] {\n  // Track which row is in actionable in state\n  const [currentTabbableKey, setCurrentTabbableKey] = useState<K>();\n  const disableTabbableMode = useCallback(\n    (target: EventTarget | null, isKeyboardEvent = false) => {\n      setCurrentTabbableKey(undefined);\n      onTabbableModeDisable && onTabbableModeDisable(target, isKeyboardEvent);\n    },\n    [onTabbableModeDisable, setCurrentTabbableKey]\n  );\n  const enableTabbableMode = useCallback(\n    (key: K) => {\n      setCurrentTabbableKey(key);\n      onTabbableModeEnable && onTabbableModeEnable(key);\n    },\n    [onTabbableModeEnable, setCurrentTabbableKey]\n  );\n  const isCurrentTabbableKey = useCallback(\n    (key?: K) => {\n      return key === currentTabbableKey;\n    },\n    [currentTabbableKey]\n  );\n\n  const onFocus = (event: FocusEvent) => {\n    const key = keyExtractor(event.target as HTMLElement) as K;\n    if (isKeyDefined(key) && !isCurrentTabbableKey(key)) {\n      enableTabbableMode(key);\n    }\n  };\n\n  const onBlur = (event: FocusEvent) => {\n    if (!event.relatedTarget || !contains(event.relatedTarget as Element)) {\n      disableTabbableMode(event.relatedTarget);\n    }\n  };\n\n  const onPointerDown = (event: MouseEvent) => {\n    const key = keyExtractor(event.target as HTMLElement) as K;\n    if (currentTabbableKey !== undefined && !isCurrentTabbableKey(key)) {\n      disableTabbableMode(event.target);\n    }\n  };\n\n  const onKeyUp = useCallback(\n    (event: KeyboardEvent) => {\n      if (event.key === 'F2') {\n        currentKey !== undefined && !isCurrentTabbableKey(currentKey)\n          ? enableTabbableMode(currentKey)\n          : disableTabbableMode(event.target, true);\n      }\n      if (event.key === 'Esc' || event.key === 'Escape') {\n        disableTabbableMode(event.target, true);\n      }\n    },\n    [currentKey, disableTabbableMode, enableTabbableMode, isCurrentTabbableKey]\n  );\n\n  const tabbableSetProps = {\n    onFocus,\n    onBlur,\n    onKeyUp,\n    onPointerDown\n  };\n\n  return [isCurrentTabbableKey, tabbableSetProps];\n}\n"],"names":["contains","keyExtractor","currentKey","onTabbableModeDisable","onTabbableModeEnable","currentTabbableKey","setCurrentTabbableKey","useState","disableTabbableMode","useCallback","target","isKeyboardEvent","undefined","enableTabbableMode","key","isCurrentTabbableKey","tabbableSetProps","onFocus","event","isKeyDefined","onBlur","relatedTarget","onKeyUp","onPointerDown"],"mappings":"4GAqBM,SACJA,EACAC,EACAC,EACAC,EACAC,GAWA,MAAOC,EAAoBC,GAAyBC,EAAQA,WACtDC,EAAsBC,EAAWA,aACrC,CAACC,EAA4BC,GAAkB,KAC7CL,OAAsBM,GACtBT,GAAyBA,EAAsBO,EAAQC,KAEzD,CAACR,EAAuBG,IAEpBO,EAAqBJ,eACxBK,IACCR,EAAsBQ,GACtBV,GAAwBA,EAAqBU,KAE/C,CAACV,EAAsBE,IAEnBS,EAAuBN,eAC1BK,GACQA,IAAQT,GAEjB,CAACA,IAqCGW,EAAmB,CACvBC,QAnCeC,IACf,MAAMJ,EAAMb,EAAaiB,EAAMR,QAC3BS,EAAYA,aAACL,KAASC,EAAqBD,IAC7CD,EAAmBC,IAiCrBM,OA7BcF,IACTA,EAAMG,eAAkBrB,EAASkB,EAAMG,gBAC1Cb,EAAoBU,EAAMG,gBA4B5BC,QAjBcb,eACbS,IACmB,OAAdA,EAAMJ,WACOF,IAAfV,GAA6Ba,EAAqBb,GAE9CM,EAAoBU,EAAMR,QAAQ,GADlCG,EAAmBX,IAGP,QAAdgB,EAAMJ,KAA+B,WAAdI,EAAMJ,KAC/BN,EAAoBU,EAAMR,QAAQ,KAGtC,CAACR,EAAYM,EAAqBK,EAAoBE,IAOtDQ,cAzBqBL,IACrB,MAAMJ,EAAMb,EAAaiB,EAAMR,aACJE,IAAvBP,GAAqCU,EAAqBD,IAC5DN,EAAoBU,EAAMR,UAyB9B,MAAO,CAACK,EAAsBC"}

package/amd/hooks/UNSAFE_useActionable.js

@@ -0,0 +1,2 @@
+define(["exports","../utils/UNSAFE_mergeProps","./UNSAFE_useHover","./UNSAFE_useActive","./UNSAFE_useFocus","./UNSAFE_usePress","./UNSAFE_useToggle","preact/hooks"],(function(s,e,i,o,r,t,u,c){"use strict";const a={isDisabled:!1,isRepeat:!1};s.useActionable=function(s,u=a){const c=Object.assign(Object.assign({},a),u),{pressProps:l}=t.usePress(s,c),{hoverProps:n,isHover:b}=i.useHover({isDisabled:c.isDisabled}),{focusProps:p,isFocus:v}=r.useFocus({isDisabled:c.isDisabled}),{activeProps:A,isActive:d}=o.useActive({isDisabled:c.isDisabled});return{actionableProps:e.mergeProps(l,n,A,p),isActive:d,isHover:b,isFocus:v}},Object.defineProperty(s,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useActionable.js.map

package/amd/hooks/UNSAFE_useActionable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useActionable.js","sources":["../../../src/hooks/UNSAFE_useActionable/useActionable.ts"],"sourcesContent":["import { mergeProps } from '../../utils/UNSAFE_mergeProps';\nimport { useHover } from '../UNSAFE_useHover';\nimport { useActive } from '../UNSAFE_useActive';\nimport { useFocus } from '../UNSAFE_useFocus';\nimport { usePress } from '../UNSAFE_usePress';\n\nexport type ActionableOptions = {\n  isDisabled?: boolean;\n  isRepeat?: boolean;\n};\n\nconst DefaultActionableOptions = {\n  isDisabled: false,\n  isRepeat: false\n};\n\n/**\n * A hook that can add actionable support to a target element, turning it into a\n * clickable button, div, card, etc.\n * If isHover, isFocus, and isActive are only used for changing visual rendering, it would be\n * faster to not use this hook, and instead use :hover, :focus-visible, :active and usePress.\n * @param onActionHandler\n * @returns\n */\nexport function useActionable(\n  onActionHandler: (event: Event) => void,\n  settings: ActionableOptions = DefaultActionableOptions\n): { isActive: boolean; isHover: boolean; isFocus: boolean; actionableProps: Record<string, any> } {\n  const mergedSettings = { ...DefaultActionableOptions, ...settings };\n  const { pressProps } = usePress(onActionHandler, mergedSettings);\n  const { hoverProps, isHover } = useHover({ isDisabled: mergedSettings.isDisabled });\n  const { focusProps, isFocus } = useFocus({ isDisabled: mergedSettings.isDisabled });\n  const { activeProps, isActive } = useActive({ isDisabled: mergedSettings.isDisabled });\n  const actionableProps = mergeProps(pressProps, hoverProps, activeProps, focusProps);\n  return { actionableProps, isActive, isHover, isFocus };\n}\n"],"names":["DefaultActionableOptions","isDisabled","isRepeat","onActionHandler","settings","mergedSettings","Object","assign","pressProps","usePress","hoverProps","isHover","useHover","focusProps","isFocus","useFocus","activeProps","isActive","useActive","actionableProps","mergeProps"],"mappings":"6MAWA,MAAMA,EAA2B,CAC/BC,YAAY,EACZC,UAAU,4BAYVC,EACAC,EAA8BJ,GAE9B,MAAMK,EAAsBC,OAAAC,OAAAD,OAAAC,OAAA,GAAAP,GAA6BI,IACnDI,WAAEA,GAAeC,EAAQA,SAACN,EAAiBE,IAC3CK,WAAEA,EAAFC,QAAcA,GAAYC,EAAAA,SAAS,CAAEX,WAAYI,EAAeJ,cAChEY,WAAEA,EAAFC,QAAcA,GAAYC,EAAAA,SAAS,CAAEd,WAAYI,EAAeJ,cAChEe,YAAEA,EAAFC,SAAeA,GAAaC,EAAAA,UAAU,CAAEjB,WAAYI,EAAeJ,aAEzE,MAAO,CAAEkB,gBADeC,EAAAA,WAAWZ,EAAYE,EAAYM,EAAaH,GAC9CI,SAAAA,EAAUN,QAAAA,EAASG,QAAAA"}

package/amd/hooks/UNSAFE_useActive.js

@@ -0,0 +1,2 @@
+define(["exports","./UNSAFE_useToggle","preact/hooks"],(function(e,o,s){"use strict";const n=e=>!(1!=(1&(void 0!==e.buttons?e.buttons:e.which)));e.useActive=function(e={isDisabled:!1}){const{bool:u,setTrue:t,setFalse:c}=o.useToggle(!1),l=s.useRef(!1),a=s.useCallback((e=>{n(e)&&t()}),[t]),r=s.useCallback((e=>{n(e)&&(l.current=!0),c()}),[c]),i=s.useCallback((e=>{l.current&&(n(e)&&t(),l.current=!1)}),[t]),b=s.useCallback((e=>{" "!==e.key&&"Enter"!==e.key||t()}),[t]),d=s.useCallback((()=>{c()}),[c]),k=e.isDisabled?{}:{onMouseDown:a,onMouseOut:r,onMouseEnter:i,onMouseUp:c,onTouchStart:t,onTouchEnd:c,onTouchCancel:c,onKeyDown:b,onKeyUp:d};return{isActive:!e.isDisabled&&u,activeProps:k}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useActive.js.map

package/amd/hooks/UNSAFE_useActive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useActive.js","sources":["../../../src/hooks/UNSAFE_useActive/useActive.ts"],"sourcesContent":["import { useToggle } from '../UNSAFE_useToggle';\nimport { useRef, useCallback } from 'preact/hooks';\n\nexport type ActiveOptions = {\n  isDisabled?: boolean;\n};\n\n/**\n * Indicates if primary mouse button is down\n * @param e\n * @returns\n */\nconst isPrimaryMouseButtonDown = (e: MouseEvent) => {\n  const flags = e.buttons !== undefined ? e.buttons : e.which;\n  const primaryMouseButtonDown = (flags & 1) === 1;\n  if (primaryMouseButtonDown) {\n    return true;\n  }\n  return false;\n};\n\n/**\n * Returns properties to manage active state indication\n * @returns\n */\nexport function useActive(settings: ActiveOptions = { isDisabled: false }): {\n  isActive: boolean;\n  activeProps: Record<string, any>;\n} {\n  const { bool, setTrue, setFalse } = useToggle(false);\n  const wasActive = useRef(false);\n\n  const mouseDownTarget = useCallback(\n    (e: MouseEvent) => {\n      if (isPrimaryMouseButtonDown(e)) {\n        setTrue();\n      }\n    },\n    [setTrue]\n  );\n\n  const leftTarget = useCallback(\n    (e: MouseEvent) => {\n      if (isPrimaryMouseButtonDown(e)) {\n        wasActive.current = true;\n      }\n      setFalse();\n    },\n    [setFalse]\n  );\n\n  const enteredTarget = useCallback(\n    (e: MouseEvent) => {\n      if (wasActive.current) {\n        if (isPrimaryMouseButtonDown(e)) {\n          setTrue();\n        }\n        wasActive.current = false;\n      }\n    },\n    [setTrue]\n  );\n\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (event.key === ' ' || event.key === 'Enter') {\n        setTrue();\n      }\n    },\n    [setTrue]\n  );\n\n  const onKeyUp = useCallback(() => {\n    setFalse();\n  }, [setFalse]);\n\n  const activeProps = settings.isDisabled\n    ? {}\n    : {\n        onMouseDown: mouseDownTarget,\n        onMouseOut: leftTarget,\n        onMouseEnter: enteredTarget,\n        onMouseUp: setFalse,\n        onTouchStart: setTrue,\n        onTouchEnd: setFalse,\n        onTouchCancel: setFalse,\n        onKeyDown,\n        onKeyUp\n      };\n\n  return {\n    isActive: settings.isDisabled ? false : bool,\n    activeProps: activeProps\n  };\n}\n"],"names":["isPrimaryMouseButtonDown","e","undefined","buttons","which","settings","isDisabled","bool","setTrue","setFalse","useToggle","wasActive","useRef","mouseDownTarget","useCallback","leftTarget","current","enteredTarget","onKeyDown","event","key","onKeyUp","activeProps","onMouseDown","onMouseOut","onMouseEnter","onMouseUp","onTouchStart","onTouchEnd","onTouchCancel","isActive"],"mappings":"qFAYA,MAAMA,EAA4BC,KAEe,IAAP,QADZC,IAAdD,EAAEE,QAAwBF,EAAEE,QAAUF,EAAEG,qBAYlD,SAAoBC,EAA0B,CAAEC,YAAY,IAIhE,MAAMC,KAAEA,EAAFC,QAAQA,EAARC,SAAiBA,GAAaC,EAAAA,WAAU,GACxCC,EAAYC,UAAO,GAEnBC,EAAkBC,eACrBb,IACKD,EAAyBC,IAC3BO,MAGJ,CAACA,IAGGO,EAAaD,eAChBb,IACKD,EAAyBC,KAC3BU,EAAUK,SAAU,GAEtBP,MAEF,CAACA,IAGGQ,EAAgBH,eACnBb,IACKU,EAAUK,UACRhB,EAAyBC,IAC3BO,IAEFG,EAAUK,SAAU,KAGxB,CAACR,IAGGU,EAAYJ,eACfK,IACmB,MAAdA,EAAMC,KAA6B,UAAdD,EAAMC,KAC7BZ,MAGJ,CAACA,IAGGa,EAAUP,EAAAA,aAAY,KAC1BL,MACC,CAACA,IAEEa,EAAcjB,EAASC,WACzB,GACA,CACEiB,YAAaV,EACbW,WAAYT,EACZU,aAAcR,EACdS,UAAWjB,EACXkB,aAAcnB,EACdoB,WAAYnB,EACZoB,cAAepB,EACfS,UAAAA,EACAG,QAAAA,GAGN,MAAO,CACLS,UAAUzB,EAASC,YAAqBC,EACxCe,YAAaA"}

package/amd/hooks/UNSAFE_useAnimation.js

@@ -0,0 +1,2 @@
+define(["exports","../useAnimation-8e4e9999","preact/hooks","../tslib.es6-d070fafc"],(function(e,i,t,n){"use strict";e.useAnimation=i.useAnimation,Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useAnimation.js.map

package/amd/hooks/UNSAFE_useAnimation.js.map

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

package/amd/hooks/UNSAFE_useBreakpointValues.js

@@ -0,0 +1,2 @@
+define(["exports","./UNSAFE_useBreakpoints","preact/hooks"],(function(e,t,n){"use strict";e.useBreakpointValues=function(e,n=t.defaultBreakpoints){const r=t.useBreakpoints(n);return Object.entries(e).reduce(((e,t)=>{const n=t[0];return r[n]?t:e}))[1]},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useBreakpointValues.js.map

package/amd/hooks/UNSAFE_useBreakpointValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useBreakpointValues.js","sources":["../../../src/hooks/UNSAFE_useBreakpointValues/useBreakpointValues.ts"],"sourcesContent":["import { useBreakpoints, Breakpoints, defaultBreakpoints } 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 *\n * TODO: Fix breakpoint value Type:\n *  The second arg allows arbitrary breakpoints to be specified, but the first arg only allows values for \"sm\", \"md\", \"lg\" and \"xl\"; if we allow custom breakpoints to be specified via the second arg, the first arg needs to allow values for those same custom breakpoints to be passed in.\n */\nexport function useBreakpointValues<V>(\n  breakpointValues: Responsive<V>,\n  breakpoints: Breakpoints = defaultBreakpoints\n) {\n  const current = useBreakpoints(breakpoints);\n\n  const breakpoint = Object.entries(breakpointValues).reduce((p, c) => {\n    const key = c[0]; // first entry in breakpoint values is the key\n    return current[key] ? c : p; // if current breakpoint is true, return it, else stay with previous\n  });\n\n  return breakpoint[1]; // second entry in breakpoint values is the value\n}\n"],"names":["breakpointValues","breakpoints","defaultBreakpoints","current","useBreakpoints","Object","entries","reduce","p","c","key"],"mappings":"yHAkBEA,EACAC,EAA2BC,sBAE3B,MAAMC,EAAUC,iBAAeH,GAO/B,OALmBI,OAAOC,QAAQN,GAAkBO,QAAO,CAACC,EAAGC,KAC7D,MAAMC,EAAMD,EAAE,GACd,OAAON,EAAQO,GAAOD,EAAID,KAGV"}

package/amd/hooks/UNSAFE_useBreakpoints.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,t){"use strict";const n={sm:"0px",md:"600px",lg:"1024px",xl:"1440px"};e.defaultBreakpoints=n,e.useBreakpoints=function(e=n){const s=t.useCallback((()=>{const t={};return Object.entries(e).forEach((([e,n])=>{t[e]=window.matchMedia(`(min-width: ${n})`).matches})),t}),[e]),[r,i]=t.useState((()=>s()));return t.useEffect((()=>{const e=()=>{i(s())};return window.addEventListener("resize",e),()=>{window.removeEventListener("resize",e)}}),[s]),r},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useBreakpoints.js.map

package/amd/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":["defaultBreakpoints","sm","md","lg","xl","breakpoints","queryMatches","useCallback","currentMatches","Object","entries","forEach","key","value","window","matchMedia","matches","setMatches","useState","useEffect","onResize","addEventListener","removeEventListener"],"mappings":"8DAOa,MAAAA,EAAqB,CAChCC,GAAI,MACJC,GAAI,QACJC,GAAI,SACJC,GAAI,kDAcU,SAAeC,EAA2BL,GAExD,MAAMM,EAAeC,EAAAA,aAAY,KAC/B,MAAMC,EAA0C,GAIhD,OAHAC,OAAOC,QAAQL,GAAaM,SAAQ,EAAEC,EAAKC,MACzCL,EAAeI,GAAOE,OAAOC,WAAW,eAAeF,MAAUG,WAE5DR,IACN,CAACH,KAEGW,EAASC,GAAcC,EAAAA,UAAS,IAAMZ,MAa7C,OAXAa,EAAAA,WAAU,KACR,MAAMC,EAAW,KACfH,EAAWX,MAIb,OADAQ,OAAOO,iBAAiB,SAAUD,GAC3B,KACLN,OAAOQ,oBAAoB,SAAUF,MAEtC,CAACd,IAEGU"}

package/amd/hooks/UNSAFE_useClearIcon.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","./UNSAFE_useToggle"],(function(e,s,l){"use strict";e.useClearIcon=function({clearIcon:e,display:o,hasValue:u,isEnabled:a=!0,isFocused:n=!1,isHover:t=!1}){const c=s.useCallback((()=>a&&("always"===o||"conditionally"===o&&u&&(n||t))),[o,u,a,n,t]),{bool:i,setFalse:r,setTrue:d}=l.useToggle(c());return s.useEffect((()=>{c()?d():r()}),[c]),i?e:null},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useClearIcon.js.map

package/amd/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":["clearIcon","display","hasValue","isEnabled","isFocused","isHover","shouldRenderClearIcon","useCallback","bool","setFalse","setTrue","useToggle","useEffect"],"mappings":"oGAgBM,UAAuBA,UAC3BA,EAD2BC,QAE3BA,EAF2BC,SAG3BA,EAH2BC,UAI3BA,GAAY,EAJeC,UAK3BA,GAAY,EALeC,QAM3BA,GAAU,IAEV,MAAMC,EAAwBC,EAAWA,aACvC,IACEJ,IACa,WAAZF,GAAqC,kBAAZA,GAA+BC,IAAaE,GAAaC,KACrF,CAACJ,EAASC,EAAUC,EAAWC,EAAWC,KAEtCG,KAAEA,EAAFC,SAAQA,EAARC,QAAkBA,GAAYC,EAASA,UAACL,KAM9C,OAJAM,EAAAA,WAAU,KACRN,IAA0BI,IAAYD,MACrC,CAACH,IAEGE,EAAOR,EAAY"}

package/amd/hooks/UNSAFE_useColorScheme.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../UNSAFE_Environment","preact","preact/jsx-runtime","../UNSAFE_Layer","preact/compat"],(function(e,t,n,o,r,c,u){"use strict";e.useColorScheme=function(){return t.useContext(n.EnvironmentContext).colorScheme},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useColorScheme.js.map

package/amd/hooks/UNSAFE_useColorScheme.js.map

@@ -0,0 +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":"4LAWE,OAAOA,EAAUA,WAACC,sBAAoBC"}

package/amd/hooks/UNSAFE_useContainerBreakpointValues.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useContainerBreakpointValues.js.map

package/amd/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":["breakpointValues","breakpoints","defaultBreakpoints","breakpointMatches","ref","useContainerBreakpoints","breakpoint","Object","entries","reduce","p","c","key"],"mappings":"uKAgBEA,EACAC,EAA2BC,sBAE3B,MAAMC,kBAAEA,EAAFC,IAAqBA,GAAQC,EAAuBA,wBAACJ,GAS3D,MAAO,CAAEK,WAPMC,OAAOC,QAAQR,GAAkBS,QAAO,CAACC,EAAGC,KACzD,MAAMC,EAAMD,EAAE,GACd,OAAOR,EAAkBS,GAAOD,EAAID,KAGZ,GAELN,IAAAA"}

package/amd/hooks/UNSAFE_useContainerBreakpoints.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useContainerBreakpoints.js.map

package/amd/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":["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":"oHASgB,SAAwBA,EAA2BC,sBACjE,MAAOC,EAAOC,GAAYC,EAAQA,SAAC,GAC7BC,EAAkBC,SAA2B,MAE7CC,EAAiBC,EAAOA,SAC5B,IACE,IAAIC,gBAAgBC,IAClB,IAAK,MAAMC,KAASD,EAClBP,EAASQ,EAAMC,YAAYV,WAGjC,IAGIW,EAAMC,eACTC,IACC,MAAMC,EAAeX,EAAgBY,QAEjCF,GAAQC,IACNA,GACFT,EAAeW,UAAUF,GAGvBD,GACFR,EAAeY,QAAQJ,GAGzBV,EAAgBY,QAAUF,KAG9B,CAACR,IAWH,MAAO,CAAEa,kBARiBZ,EAAAA,SAAQ,KAChC,MAAMa,EAAmC,GACzC,IAAK,MAAMC,KAAKtB,EACdqB,EAAQC,GAAKpB,GAASqB,SAASvB,EAAYsB,IAE7C,OAAOD,IACN,CAACnB,EAAOF,IAEiBa,IAAAA"}

package/amd/hooks/UNSAFE_useCurrentValueReducer.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useCurrentValueReducer.js.map

package/amd/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":["currentValueReducer","state","type","payload","Object","assign","currentInputValue","currentCommitValue","Error","value","dispatch","useReducer","useEffect"],"mappings":"8DAoBA,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,8BAA8BN,gCAoB9B,UAAuBO,MAAEA,IACvC,MAAOR,EAAOS,GAAYC,EAAAA,WAAWX,EAAqB,CACxDM,kBAAmBG,EACnBF,mBAAoBE,IAkBtB,OAfAG,EAAAA,WAAU,KAIwBH,IAAUR,EAAMK,mBAO9CI,EAAS,CAAER,KAAM,SAAUC,QAASM,MAErC,CAACA,EAAOR,EAAMK,oBAEV,CACLC,mBAAoBN,EAAMM,mBAC1BG,SAAAA"}

package/amd/hooks/UNSAFE_useDebounce.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useDebounce.js.map

package/amd/hooks/UNSAFE_useDebounce.js.map

@@ -0,0 +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":"4EAgBgB,SAAeA,EAAUC,GACvC,MAAOC,EAAgBC,GAAqBC,EAAQA,SAACJ,GAcrD,OAZAK,EAAAA,WAAU,KAER,MAAMC,EAAYC,YAAW,KAC3BJ,EAAkBH,KACjBC,GAKH,MAAO,IAAMO,aAAaF,KACzB,CAACN,EAAOC,IAEJC"}

package/amd/hooks/UNSAFE_useFloating.js

@@ -0,0 +1,2 @@
+define(["exports","../index-2f5333e8","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})}));
+//# sourceMappingURL=UNSAFE_useFloating.js.map

package/amd/hooks/UNSAFE_useFloating.js.map

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

package/amd/hooks/UNSAFE_useFocus.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useFocus.js.map

package/amd/hooks/UNSAFE_useFocus.js.map

@@ -0,0 +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":"gGAUM,SAAmBA,EAAyB,CAAEC,YAAY,IAI9D,MAAMC,KAAEA,EAAFC,QAAQA,EAARC,SAAiBA,GAAaC,EAAAA,WAAU,GACxCC,EAAaN,EAASC,WACxB,GACA,CACEM,QAASJ,EACTK,OAAQJ,GAEd,MAAO,CACLK,SAAST,EAASC,YAAqBC,EACvCI,WAAYA"}

package/amd/hooks/UNSAFE_useFocusWithin.js

@@ -0,0 +1,2 @@
+define(["exports","../useFocusWithin-7378d9c7","preact/hooks"],(function(e,s,i){"use strict";e.useFocusWithin=s.useFocusWithin,Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useFocusWithin.js.map

package/amd/hooks/UNSAFE_useFocusWithin.js.map

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

package/amd/hooks/UNSAFE_useFocusableTextField.js

@@ -0,0 +1,2 @@
+define(["exports","../tslib.es6-d070fafc","preact/hooks","./UNSAFE_useFocusWithin","../useFocusWithin-7378d9c7"],(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:c,isFocused:l}=n.useFocusWithin(t),i=r.useRef(l),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=l}),[l]),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:l,focusProps:c}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useFocusableTextField.js.map

package/amd/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":["_a","isReadonly","ref","useFocusWithinProps","__rest","focusProps","isFocused","useFocusWithin","previousIsFocusedRef","useRef","enabledElementRef","readonlyElementRef","useEffect","current","setTimeout","focus","useImperativeHandle","_b","blur"],"mappings":"2KA2BM,SAA8EA,GAAA,IAAAC,WAClFA,EADkFC,IAElFA,EAAM,UAEqBF,EADxBG,EAAmBC,EAAAA,OAAAJ,EAH4D,sBAKlF,MAAMK,WAAEA,EAAFC,UAAcA,GAAcC,EAAcA,eAACJ,GAE3CK,EAAuBC,SAAOH,GAC9BI,EAAoBD,SAAU,MAC9BE,EAAqBF,SAAU,MA2CrC,OAxCAG,EAAAA,WAAU,KAGJJ,EAAqBK,UACnBZ,EACFa,YAAW,KAAK,IAAAd,EAAC,eAAAA,EAAAW,EAAmBE,8BAASE,WAE7CD,YAAW,KAAK,IAAAd,EAAC,eAAAA,EAAAU,EAAkBG,8BAASE,cAG/C,CAACd,IAIJW,EAAAA,WAAU,KACRJ,EAAqBK,QAAUP,IAC9B,CAACA,IAGJU,EAAmBA,oBACjBd,GACA,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,WAIjC,CAACjB,IAGI,CACLS,kBAAAA,EACAC,mBAAAA,EACAL,UAAAA,EACAD,WAAAA"}

package/amd/hooks/UNSAFE_useFormContext.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useFormContext.js.map

package/amd/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":["DefaultFormContext","isDisabled","isFormLayout","isReadonly","labelEdge","labelStartWidth","labelWrapping","textAlign","userAssistanceDensity","FormContext","createContext","context","useContext","Object","assign"],"mappings":"yEA2CA,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"}

package/amd/hooks/UNSAFE_useFormFieldContext.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useFormFieldContext.js.map

package/amd/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":["FormFieldContext","createContext","hasValue","isDisabled","isFocused","isLoading","isReadonly","useContext"],"mappings":"yEAgFM,MAAAA,EAAmBC,EAAAA,cAAqC,CAC5DC,UAAU,EACVC,YAAY,EACZC,WAAW,EACXC,WAAW,EACXC,YAAY,+CC7Ed,WACE,OAAOC,EAAAA,WAAWP"}

package/amd/hooks/UNSAFE_useFormVariantContext.js

@@ -0,0 +1,2 @@
+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})}));
+//# sourceMappingURL=UNSAFE_useFormVariantContext.js.map

package/amd/hooks/UNSAFE_useFormVariantContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useFormVariantContext.js","sources":["../../../src/hooks/UNSAFE_useFormVariantContext/FormVariantContext.ts","../../../src/hooks/UNSAFE_useFormVariantContext/useFormVariantContext.ts"],"sourcesContent":["import { createContext } from 'preact';\n\n/**\n * Context which an ancestor component can use to provide a value for the 'variant' property\n * of the descendant form fields.\n */\nexport const FormVariantContext = createContext<'default' | 'embedded' | undefined>('default');\n","import { useContext } from 'preact/hooks';\nimport { FormVariantContext } from './FormVariantContext';\n\n/**\n * Utility hook for consuming the FormVariantContext\n *\n * @returns The value of the closest FormVariantContext provider\n */\nexport function useFormVariantContext() {\n  return useContext(FormVariantContext);\n}\n"],"names":["FormVariantContext","createContext","useContext"],"mappings":"+EAMaA,EAAqBC,EAAaA,cAAqC,qECGlF,OAAOC,EAAAA,WAAWF"}

package/amd/hooks/UNSAFE_useHover.js

@@ -0,0 +1,2 @@
+define(["exports","./UNSAFE_useToggle","preact/hooks"],(function(e,s,o){"use strict";e.useHover=function(e={isDisabled:!1}){const{bool:o,setTrue:t,setFalse:u}=s.useToggle(!1),{bool:r,setTrue:n,setFalse:i}=s.useToggle(!1),l=e.isDisabled?{}:{ontouchend:n,onMouseEnter:()=>{r?i():t()},onMouseLeave:u};return{isHover:!e.isDisabled&&o,hoverProps:l}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useHover.js.map

package/amd/hooks/UNSAFE_useHover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useHover.js","sources":["../../../src/hooks/UNSAFE_useHover/useHover.ts"],"sourcesContent":["import { useToggle } from '../UNSAFE_useToggle';\n\nexport type HoverOptions = {\n  isDisabled?: boolean;\n};\n\n/**\n * Returns listeners and status for hover\n * If only visual changes are required, :hover is faster.\n *\n * @returns\n */\nexport function useHover(settings: HoverOptions = { isDisabled: false }): {\n  isHover: boolean;\n  hoverProps: Record<string, any>;\n} {\n  // :hover is faster than event handlers, but doesn't work for all platforms.\n  // For touch-first devices, the media query for hover is enough.\n  // Hybrid devices support hover upon pointer usage, but tapping would toggle hover state\n  // so disable :hover and use event handlers for such devices.\n  // Use getClientHints to check if hybrid\n  // const hybrid = getClientHints().isHybrid;\n  // Classes can be done via :\n  //     !isHybrid && compStyles.pseudohover,\n  //      isHybrid && isHover && compStyles.hover\n  // and the props can be done via:\n  //     const { hoverProps, isHover } = useHover( {isDisabled: isHybrid});\n  //\n  // For the algorithm below, There are 2 possible sequences:\n  // 1. A pointer (mouse, trackpad) would generate a mouseEnter event that would initiate hover.\n  // 2. A touch generates a touchstart/touchend/mouseEnter event sequence.\n  // Hover has no meaning in a touch context, so the isHover state should be avoided.\n  // To avoid, we set an ignore flag when a touchend is encountered.\n  // Each time mouseEnter is encountered, the flag is checked.\n  // If ignore, we know that it is a touch device, so don't set hover state.\n  // In all cases, reset the flag for the next sequence.\n  //\n  const { bool, setTrue, setFalse } = useToggle(false);\n  const { bool: ignore, setTrue: setIgnoreTrue, setFalse: setIgnoreFalse } = useToggle(false);\n  const startHover = () => {\n    if (ignore) {\n      setIgnoreFalse();\n    } else {\n      setTrue();\n    }\n  };\n\n  const hoverProps = settings.isDisabled\n    ? {}\n    : { ontouchend: setIgnoreTrue, onMouseEnter: startHover, onMouseLeave: setFalse };\n  return {\n    isHover: settings.isDisabled ? false : bool,\n    hoverProps: hoverProps\n  };\n}\n"],"names":["settings","isDisabled","bool","setTrue","setFalse","useToggle","ignore","setIgnoreTrue","setIgnoreFalse","hoverProps","ontouchend","onMouseEnter","onMouseLeave","isHover"],"mappings":"gGAYM,SAAmBA,EAAyB,CAAEC,YAAY,IAyB9D,MAAMC,KAAEA,EAAFC,QAAQA,EAARC,SAAiBA,GAAaC,EAAAA,WAAU,IACtCH,KAAMI,EAAQH,QAASI,EAAeH,SAAUI,GAAmBH,aAAU,GAS/EI,EAAaT,EAASC,WACxB,GACA,CAAES,WAAYH,EAAeI,aAVd,KACbL,EACFE,IAEAL,KAMuDS,aAAcR,GACzE,MAAO,CACLS,SAASb,EAASC,YAAqBC,EACvCO,WAAYA"}

package/amd/hooks/UNSAFE_useId.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,t){"use strict";e.useId=()=>{const[e]=t.useState((()=>`_${Math.random().toString(36).slice(2)}`));return e},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useId.js.map

package/amd/hooks/UNSAFE_useId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useId.js","sources":["../../../src/hooks/UNSAFE_useId/useId.tsx"],"sourcesContent":["import { useState } from 'preact/hooks';\n\n/**\n * Generates random string that can be used as ID. Serves as replacement for\n * getUniqueId() function from \"ojs/ojvcomponent-preact\", until React 18 is\n * released with useId hook (https://github.com/preactjs/preact/issues/3373).\n * 1. Pick a random number in the range between 0 (inclusive) and 1 (exclusive)\n * 2. Convert the number to a base-36 string (using characters 0-9 and a-z)\n * 3. Slice off the leading '0.' prefix\n * 4. ids should always start with a letter, so prefix it with 'id'\n */\nexport const useId = () => {\n  const [id] = useState(() => `_${Math.random().toString(36).slice(2)}`); //@RandomNumberOK\n  return id;\n};\n"],"names":["id","useState","Math","random","toString","slice"],"mappings":"sEAWqB,KACnB,MAAOA,GAAMC,EAAAA,UAAS,IAAM,IAAIC,KAAKC,SAASC,SAAS,IAAIC,MAAM,OACjE,OAAOL"}

package/amd/hooks/UNSAFE_useLengthFilter.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../utils/UNSAFE_lengthFilter"],(function(e,t,n){"use strict";e.useLengthFilter=function({maxLength:e,maxLengthUnit:u,onCommit:l,onInput:s,value:a}){const[i,o]=t.useState(!1),c=t.useCallback((t=>n.filter(t,e,u)),[e,u]);t.useEffect((()=>{if(void 0===a)return;const e=c(a);e!==a?(null==s||s({previousValue:a,value:e}),null==l||l({previousValue:a,value:e}),o(!0)):o(!1)}),[a,l,s,c]);const r=t.useCallback(((...e)=>{const{previousValue:t,value:n}=e[0],u=c(null!=n?n:"");t!==u?(null==s||s(Object.assign(Object.assign({},e[0]),{value:u})),o(!1)):o(!0)}),[s,c]);return{isMaxLengthExceeded:i,valueLength:void 0===a?void 0:n.calcLength(a,u),onFilteredInput:r}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useLengthFilter.js.map

package/amd/hooks/UNSAFE_useLengthFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useLengthFilter.js","sources":["../../../src/hooks/UNSAFE_useLengthFilter/useLengthFilter.ts"],"sourcesContent":["import { ComponentProps } from 'preact';\nimport { useCallback, useEffect, useState } from 'preact/hooks';\nimport { TextFieldInput } from '../../UNSAFE_TextField';\nimport { calcLength, CountUnit as _CountUnit, filter } from '../../utils/UNSAFE_lengthFilter';\n\nexport type CountUnit = _CountUnit;\n\ntype PickedPropsFromTextFieldInput = Pick<\n  ComponentProps<typeof TextFieldInput>,\n  'onCommit' | 'onInput' | 'value'\n>;\ntype UseLengthFilterProps = PickedPropsFromTextFieldInput & {\n  maxLength?: number;\n  maxLengthUnit?: CountUnit;\n};\n\n/**\n * A custom hook that applies the length filter to text field input\n * @param param0 The props for the useLengthFilter hook\n * @returns The filtered event handlers\n */\nexport function useLengthFilter({\n  maxLength,\n  maxLengthUnit,\n  onCommit,\n  onInput,\n  value\n}: UseLengthFilterProps) {\n  const [isMaxLengthExceeded, setMaxLengthExceeded] = useState(false);\n  const parse = useCallback(\n    (value: string) => filter(value, maxLength, maxLengthUnit),\n    [maxLength, maxLengthUnit]\n  );\n  // Reapply maxLength filter when the value is changed\n  useEffect(() => {\n    if (value === undefined) {\n      return;\n    }\n\n    const filteredValue = parse(value);\n    if (filteredValue !== value) {\n      onInput?.({ previousValue: value, value: filteredValue });\n      onCommit?.({ previousValue: value, value: filteredValue });\n\n      // Value is filtered, means that the max length is exceeded\n      setMaxLengthExceeded(true);\n    } else {\n      // Value is not filtered, means that the max length is not exceeded\n      setMaxLengthExceeded(false);\n    }\n  }, [value, onCommit, onInput, parse]);\n\n  const onFilteredInput = useCallback(\n    (...args: Parameters<Exclude<typeof onInput, undefined>>) => {\n      const { previousValue, value } = args[0];\n      const filteredValue = parse(value ?? '');\n\n      // Call the onInput event only when the value is changed\n      if (previousValue !== filteredValue) {\n        onInput?.({ ...args[0], value: filteredValue });\n        // value is not filtered, so the max length is not exceeded\n        setMaxLengthExceeded(false);\n      } else {\n        // value is changed but then filtered to previous value\n        // meaning that the max length was exceeded\n        setMaxLengthExceeded(true);\n      }\n    },\n    [onInput, parse]\n  );\n\n  return {\n    isMaxLengthExceeded,\n    valueLength: value === undefined ? undefined : calcLength(value, maxLengthUnit),\n    onFilteredInput\n  };\n}\n"],"names":["maxLength","maxLengthUnit","onCommit","onInput","value","isMaxLengthExceeded","setMaxLengthExceeded","useState","parse","useCallback","filter","useEffect","undefined","filteredValue","previousValue","onFilteredInput","args","valueLength","calcLength"],"mappings":"iHAqBgB,UAAgBA,UAC9BA,EAD8BC,cAE9BA,EAF8BC,SAG9BA,EAH8BC,QAI9BA,EAJ8BC,MAK9BA,IAEA,MAAOC,EAAqBC,GAAwBC,EAAQA,UAAC,GACvDC,EAAQC,EAAAA,aACXL,GAAkBM,EAAAA,OAAON,EAAOJ,EAAWC,IAC5C,CAACD,EAAWC,IAGdU,EAAAA,WAAU,KACR,QAAcC,IAAVR,EACF,OAGF,MAAMS,EAAgBL,EAAMJ,GACxBS,IAAkBT,GACpBD,MAAAA,GAAAA,EAAU,CAAEW,cAAeV,EAAOA,MAAOS,IACzCX,MAAAA,GAAAA,EAAW,CAAEY,cAAeV,EAAOA,MAAOS,IAG1CP,GAAqB,IAGrBA,GAAqB,KAEtB,CAACF,EAAOF,EAAUC,EAASK,IAE9B,MAAMO,EAAkBN,EAAAA,aACtB,IAAIO,KACF,MAAMF,cAAEA,EAAFV,MAAiBA,GAAUY,EAAK,GAChCH,EAAgBL,EAAMJ,MAAAA,EAAAA,EAAS,IAGjCU,IAAkBD,GACpBV,MAAAA,GAAAA,iCAAea,EAAK,IAAI,CAAAZ,MAAOS,KAE/BP,GAAqB,IAIrBA,GAAqB,KAGzB,CAACH,EAASK,IAGZ,MAAO,CACLH,oBAAAA,EACAY,iBAAuBL,IAAVR,OAAsBQ,EAAYM,EAAUA,WAACd,EAAOH,GACjEc,gBAAAA"}

package/amd/hooks/UNSAFE_useLoadingIndicatorTimer.js

@@ -0,0 +1,2 @@
+define(["exports","./UNSAFE_useTimer","preact/hooks"],(function(e,r,t){"use strict";e.useLoadingIndicatorTimer=function(e){return r.useTimer({isStarted:e,delay:50})},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useLoadingIndicatorTimer.js.map

package/amd/hooks/UNSAFE_useLoadingIndicatorTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useLoadingIndicatorTimer.js","sources":["../../../src/hooks/UNSAFE_useLoadingIndicatorTimer/useLoadingIndicatorTimer.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { useTimer } from '../UNSAFE_useTimer';\n\n/**\n * Hook for a timer used to determine when to show a loading indicator.\n * After the timer is started, the loading indicator should only be shown after a slight delay,\n * when the timer expires.  A loading indicator should not be shown immediately because that\n * could result in unwanted flashing in the UI.\n * @param isLoading Specifies whether the calling code is in a loading state and the timer\n * should be started: true to start it, false to stop it.\n * @returns True if the timer expires, false if it was stopped before that.\n */\nexport function useLoadingIndicatorTimer(isLoading: boolean): boolean {\n  // TODO: get delay from theme variable\n  // (--oj-private-core-global-loading-indicator-delay-duration)\n  return useTimer({ isStarted: isLoading, delay: 50 });\n}\n"],"names":["isLoading","useTimer","isStarted","delay"],"mappings":"+GAmBM,SAAmCA,GAGvC,OAAOC,EAAAA,SAAS,CAAEC,UAAWF,EAAWG,MAAO"}

package/amd/hooks/UNSAFE_useLongPress.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,n){"use strict";const t={pointerDownId:null,startTime:0};e.useLongPress=function(e,{isDisabled:o=!1,minimumTime:r=250}={isDisabled:!1,minimumTime:250}){const i=n.useRef(t),s=n.useCallback((e=>{"mouse"==e.pointerType&&0!=e.button||(i.current=i.current.pointerDownId?t:{pointerDownId:e.pointerId,startTime:e.timeStamp})}),[]),u=n.useCallback((n=>{if(n.pointerId===i.current.pointerDownId){n.timeStamp-i.current.startTime>r&&e({x:n.offsetX,y:n.offsetY})}a()}),[e]),a=n.useCallback((()=>{i.current=t}),[]);return{longPressProps:o?{}:{onPointerDown:s,onPointerUp:u,onPointerLeave:a,onPointerCancel:a}}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useLongPress.js.map

package/amd/hooks/UNSAFE_useLongPress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useLongPress.js","sources":["../../../src/hooks/UNSAFE_useLongPress/useLongPress.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * Licensed under The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { useRef, useCallback } from 'preact/hooks';\n\ntype LongPressOptions = {\n  isDisabled?: boolean;\n  minimumTime?: number;\n};\n\ntype LongPressInfo = {\n  x: number;\n  y: number;\n};\n\ntype LongPressState = {\n  pointerDownId: number | null;\n  startTime: number;\n};\n\nconst InitialPressState = {\n  pointerDownId: null,\n  startTime: 0\n};\n\nconst DefaultMinimumTime = 250;\n\nexport function useLongPress(\n  onLongPress: (e: LongPressInfo) => void,\n  { isDisabled = false, minimumTime = DefaultMinimumTime }: LongPressOptions = {\n    isDisabled: false,\n    minimumTime: DefaultMinimumTime\n  }\n): { longPressProps: Record<string, any> } {\n  const ref = useRef<LongPressState>(InitialPressState);\n\n  const onPointerDown = useCallback((e: PointerEvent) => {\n    // return if it is not a left click\n    if (e.pointerType == 'mouse' && e.button != 0) {\n      return;\n    }\n\n    ref.current = ref.current.pointerDownId\n      ? InitialPressState\n      : { pointerDownId: e.pointerId, startTime: e.timeStamp };\n  }, []);\n\n  const onPointerUp = useCallback(\n    (e: PointerEvent) => {\n      if (e.pointerId === ref.current.pointerDownId) {\n        const longPressTime = e.timeStamp - ref.current.startTime;\n        // 250ms minimum longPress time based on numbers used in Hammer\n        if (longPressTime > minimumTime) {\n          onLongPress({ x: e.offsetX, y: e.offsetY });\n        }\n      }\n      clearLongPress();\n    },\n    [onLongPress]\n  );\n\n  const clearLongPress = useCallback(() => {\n    ref.current = InitialPressState;\n  }, []);\n\n  const longPressProps = isDisabled\n    ? {}\n    : {\n        onPointerDown,\n        onPointerUp,\n        onPointerLeave: clearLongPress,\n        onPointerCancel: clearLongPress\n      };\n\n  return {\n    longPressProps\n  };\n}\n"],"names":["InitialPressState","pointerDownId","startTime","onLongPress","isDisabled","minimumTime","ref","useRef","onPointerDown","useCallback","e","pointerType","button","current","pointerId","timeStamp","onPointerUp","x","offsetX","y","offsetY","clearLongPress","longPressProps","onPointerLeave","onPointerCancel"],"mappings":"8DAyBA,MAAMA,EAAoB,CACxBC,cAAe,KACfC,UAAW,kBAKG,SACdC,GACAC,WAAEA,GAAa,EAAfC,YAAsBA,EAJG,KAIoD,CAC3ED,YAAY,EACZC,YANuB,MASzB,MAAMC,EAAMC,SAAuBP,GAE7BQ,EAAgBC,eAAaC,IAEZ,SAAjBA,EAAEC,aAAsC,GAAZD,EAAEE,SAIlCN,EAAIO,QAAUP,EAAIO,QAAQZ,cACtBD,EACA,CAAEC,cAAeS,EAAEI,UAAWZ,UAAWQ,EAAEK,cAC9C,IAEGC,EAAcP,eACjBC,IACC,GAAIA,EAAEI,YAAcR,EAAIO,QAAQZ,cAAe,CACvBS,EAAEK,UAAYT,EAAIO,QAAQX,UAE5BG,GAClBF,EAAY,CAAEc,EAAGP,EAAEQ,QAASC,EAAGT,EAAEU,UAGrCC,MAEF,CAAClB,IAGGkB,EAAiBZ,EAAAA,aAAY,KACjCH,EAAIO,QAAUb,IACb,IAWH,MAAO,CACLsB,eAVqBlB,EACnB,GACA,CACEI,cAAAA,EACAQ,YAAAA,EACAO,eAAgBF,EAChBG,gBAAiBH"}

package/amd/hooks/UNSAFE_useMessagesContext.js

@@ -0,0 +1,2 @@
+define(["exports","preact","preact/hooks"],(function(e,t,s){"use strict";const n=t.createContext({});e.MessagesContext=n,e.useMessagesContext=function(){return s.useContext(n)},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useMessagesContext.js.map

package/amd/hooks/UNSAFE_useMessagesContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useMessagesContext.js","sources":["../../../src/hooks/UNSAFE_useMessagesContext/MessagesContext.ts","../../../src/hooks/UNSAFE_useMessagesContext/useMessagesContext.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { createContext } from 'preact';\n\n/**\n * Messages Context\n */\ntype MessagesContextProps = {\n  /**\n   * An optional function that adds busy state to the root element\n   */\n  addBusyState?: (description?: string) => () => void;\n};\n\n/**\n * Context which the parent custom element components can use for passing down\n * the busy context\n */\nexport const MessagesContext = createContext<MessagesContextProps>({});\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 */\n\nimport { useContext } from 'preact/hooks';\nimport { MessagesContext } from './MessagesContext';\n\n/**\n * Uses the MessagesContext if one is available.\n *\n * @returns The context from the closes provider\n */\nexport function useMessagesContext() {\n  return useContext(MessagesContext);\n}\n"],"names":["MessagesContext","createContext","useContext"],"mappings":"+EAwBaA,EAAkBC,EAAaA,cAAuB,wDCPjE,OAAOC,EAAAA,WAAWF"}

package/amd/hooks/UNSAFE_useOutsideClick.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../utils/UNSAFE_arrayUtils"],(function(e,n,r){"use strict";const t=e=>{var n;return null!==(n=null==e?void 0:e.ownerDocument)&&void 0!==n?n:document};e.useOutsideClick=({isDisabled:e=!1,ref:o,handler:s})=>{const u=n.useRef({isMouseDown:!1}).current;n.useEffect((()=>{const n=r.coerceArray(o);if(!s||e||n.length>0&&n.findIndex((e=>null===e.current))>-1)return;const i=()=>{u.isMouseDown=!0},c=e=>{u.isMouseDown&&((e,n)=>{const r=e.target;if(r&&!t(r).contains(r))return!1;return n.every((e=>{var n;return!(null===(n=e.current)||void 0===n?void 0:n.contains(r))}))})(e,n)&&(u.isMouseDown=!1,null==s||s(e))},d=n[0],l=t(d.current);return l?(l.addEventListener("mousedown",i,!0),l.addEventListener("mouseup",c,!0),()=>{l.removeEventListener("mousedown",i,!0),l.removeEventListener("mouseup",c,!0)}):void 0}),[e,s,o,u])},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useOutsideClick.js.map

package/amd/hooks/UNSAFE_useOutsideClick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useOutsideClick.js","sources":["../../../src/hooks/UNSAFE_useOutsideClick/useOutsideClick.ts"],"sourcesContent":["/**\n * `useClickOutside` hook for capturing clicking outside of an element\n */\nimport { RefObject } from 'preact';\nimport { useEffect, useRef } from 'preact/hooks';\nimport { coerceArray } from '../../utils/UNSAFE_arrayUtils';\n\ntype Props = {\n  /**\n   * If true outside click is disabled\n   */\n  isDisabled?: boolean;\n  /**\n   * Reference to element or array of elements relative to which outside click is performed\n   */\n  ref: RefObject<HTMLElement> | RefObject<HTMLElement>[];\n  /**\n   * Outside click callback\n   */\n  handler?: (event: MouseEvent) => void;\n};\n\nconst isPointOutside = (event: Event, ref: RefObject<HTMLElement>[]) => {\n  const target = event.target as HTMLElement;\n  if (target) {\n    const doc = getDocument(target);\n    if (!doc.contains(target)) return false;\n  }\n  return ref.every((elRef) => !elRef.current?.contains(target));\n};\n\nconst getDocument = (node?: Node): Document => node?.ownerDocument ?? document;\n\nexport const useOutsideClick = ({ isDisabled: disabled = false, ref, handler }: Props) => {\n  // use ref to store mutable data and not cause a re-render\n  const stateRef = useRef({\n    isMouseDown: false\n  });\n\n  const state = stateRef.current;\n\n  useEffect(() => {\n    const refs = coerceArray(ref);\n    if (\n      !handler ||\n      disabled ||\n      (refs.length > 0 && refs.findIndex((elRef) => elRef.current === null) > -1)\n    )\n      return;\n    const onMouseDown = () => {\n      state.isMouseDown = true;\n    };\n\n    const onMouseUp = (event: MouseEvent) => {\n      if (state.isMouseDown && isPointOutside(event, refs)) {\n        state.isMouseDown = false;\n        handler?.(event);\n      }\n    };\n    const firstElRef = refs[0];\n    const doc = getDocument(firstElRef.current!);\n    if (doc) {\n      doc.addEventListener('mousedown', onMouseDown, true);\n      doc.addEventListener('mouseup', onMouseUp, true);\n\n      return () => {\n        doc.removeEventListener('mousedown', onMouseDown, true);\n        doc.removeEventListener('mouseup', onMouseUp, true);\n      };\n    }\n    return undefined;\n  }, [disabled, handler, ref, state]);\n};\n"],"names":["getDocument","node","_a","ownerDocument","document","isDisabled","disabled","ref","handler","state","useRef","isMouseDown","current","useEffect","refs","coerceArray","length","findIndex","elRef","onMouseDown","onMouseUp","event","target","contains","every","isPointOutside","firstElRef","doc","addEventListener","removeEventListener"],"mappings":"6FAsBA,MASMA,EAAeC,IAAyB,IAAAC,EAAC,eAAAA,EAAAD,MAAAA,OAAI,EAAJA,EAAME,6BAAiBC,4BAEvC,EAAGC,WAAYC,GAAW,EAAOC,IAAAA,EAAKC,QAAAA,MAEnE,MAIMC,EAJWC,EAAAA,OAAO,CACtBC,aAAa,IAGQC,QAEvBC,EAAAA,WAAU,KACR,MAAMC,EAAOC,cAAYR,GACzB,IACGC,GACDF,GACCQ,EAAKE,OAAS,GAAKF,EAAKG,WAAWC,GAA4B,OAAlBA,EAAMN,WAAqB,EAEzE,OACF,MAAMO,EAAc,KAClBV,EAAME,aAAc,GAGhBS,EAAaC,IACbZ,EAAME,aAhCO,EAACU,EAAcd,KACpC,MAAMe,EAASD,EAAMC,OACrB,GAAIA,IACUtB,EAAYsB,GACfC,SAASD,GAAS,OAAO,EAEpC,OAAOf,EAAIiB,OAAON,IAAU,IAAAhB,EAAA,QAAc,UAAbgB,EAAMN,eAAO,IAAAV,OAAA,EAAAA,EAAEqB,SAASD,QA0BxBG,CAAeJ,EAAOP,KAC7CL,EAAME,aAAc,EACpBH,MAAAA,GAAAA,EAAUa,KAGRK,EAAaZ,EAAK,GAClBa,EAAM3B,EAAY0B,EAAWd,SACnC,OAAIe,GACFA,EAAIC,iBAAiB,YAAaT,GAAa,GAC/CQ,EAAIC,iBAAiB,UAAWR,GAAW,GAEpC,KACLO,EAAIE,oBAAoB,YAAaV,GAAa,GAClDQ,EAAIE,oBAAoB,UAAWT,GAAW,UANlD,IAUC,CAACd,EAAUE,EAASD,EAAKE"}

package/amd/hooks/UNSAFE_usePan.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,t){"use strict";e.usePan=function(e,{threshold:n=50,minimumTime:r=500,isDisabled:s=!1}={threshold:50,minimumTime:500,isDisabled:!1}){const f=t.useRef({pointerDownId:0,startTime:0,prevOffsetX:0,prevOffsetY:0}),o=t.useCallback((t=>{f.current.pointerDownId?u():(f.current={pointerDownId:t.pointerId,startTime:t.timeStamp,prevOffsetX:t.offsetX,prevOffsetY:t.offsetY},null==e||e({x:t.clientX,y:t.clientY,status:"start"}))}),[]),i=t.useCallback((t=>{if(t.pointerId===f.current.pointerDownId&&f.current.startTime&&t.timeStamp-f.current.startTime>=r){const r=t.offsetX-f.current.prevOffsetX,s=t.offsetY-f.current.prevOffsetY;Math.abs(r)>Math.abs(s)?(f.current.prevOffsetX-t.offsetX>n||t.offsetX-f.current.prevOffsetX>n)&&(null==e||e({x:t.clientX,y:t.clientY,status:"end"})):(f.current.prevOffsetY-t.offsetY>n||t.offsetY-f.current.prevOffsetY>n)&&(null==e||e({x:t.clientX,y:t.clientY,status:"end"}))}u()}),[n,e]),u=t.useCallback((()=>{f.current={pointerDownId:null,startTime:null,prevOffsetX:0,prevOffsetY:0}}),[]);return{panProps:s?{}:{onPointerDown:o,onPointerUp:i,onPointerMove:t=>{f.current.pointerDownId===t.pointerId&&(null==e||e({x:t.clientX,y:t.clientY,status:"move"}))},onPointerCancel:u}}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_usePan.js.map

package/amd/hooks/UNSAFE_usePan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_usePan.js","sources":["../../../src/hooks/UNSAFE_usePan/usePan.ts"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * Licensed under The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\n\nimport { useRef, useCallback } from 'preact/hooks';\n\n/*\nthreshold: Minimal distance in pixels required before recognizing\n*/\ntype PanOptions = {\n  threshold?: number;\n  minimumTime?: number;\n  isDisabled?: boolean;\n};\n\ntype PanInfo = {\n  x: number;\n  y: number;\n  status: 'start' | 'end' | 'move';\n};\n\ntype PanState = {\n  pointerDownId: number | null;\n  startTime: number | null;\n  prevOffsetX: number;\n  prevOffsetY: number;\n};\n\nexport function usePan(\n  onPan: (e: PanInfo) => void,\n  { threshold = 50, minimumTime = 500, isDisabled = false }: PanOptions = {\n    threshold: 50,\n    minimumTime: 500,\n    isDisabled: false\n  }\n): { panProps: Record<string, any> } {\n  const ref = useRef<PanState>({\n    pointerDownId: 0,\n    startTime: 0,\n    prevOffsetX: 0,\n    prevOffsetY: 0\n  });\n\n  const onPointerDown = useCallback((e: PointerEvent) => {\n    if (!ref.current.pointerDownId) {\n      ref.current = {\n        pointerDownId: e.pointerId,\n        startTime: e.timeStamp,\n        prevOffsetX: e.offsetX,\n        prevOffsetY: e.offsetY\n      };\n      onPan?.({ x: e.clientX, y: e.clientY, status: 'start' });\n    } else {\n      clearPan();\n    }\n  }, []);\n\n  const onPointerMove = (e: PointerEvent) => {\n    if (ref.current.pointerDownId === e.pointerId) {\n      onPan?.({ x: e.clientX, y: e.clientY, status: 'move' });\n    }\n  };\n\n  const onPointerUp = useCallback(\n    (ev: PointerEvent) => {\n      if (ev.pointerId === ref.current.pointerDownId) {\n        if (ref.current.startTime && ev.timeStamp - ref.current.startTime >= minimumTime) {\n          const horizontalThreshold = ev.offsetX - ref.current.prevOffsetX;\n          const verticalThreshold = ev.offsetY - ref.current.prevOffsetY;\n          if (Math.abs(horizontalThreshold) > Math.abs(verticalThreshold)) {\n            // pan-left or pan-right\n            if (ref.current.prevOffsetX - ev.offsetX > threshold) {\n              onPan?.({ x: ev.clientX, y: ev.clientY, status: 'end' });\n            } else if (ev.offsetX - ref.current.prevOffsetX > threshold) {\n              onPan?.({ x: ev.clientX, y: ev.clientY, status: 'end' });\n            }\n          } else {\n            // pan-up or pan-down\n            if (ref.current.prevOffsetY - ev.offsetY > threshold) {\n              onPan?.({ x: ev.clientX, y: ev.clientY, status: 'end' });\n            } else if (ev.offsetY - ref.current.prevOffsetY > threshold) {\n              onPan?.({ x: ev.clientX, y: ev.clientY, status: 'end' });\n            }\n          }\n        }\n      }\n      // state would be reset to its original state whether pan is completed or cancelled\n      clearPan();\n    },\n    [threshold, onPan]\n  );\n\n  const clearPan = useCallback(() => {\n    ref.current = {\n      pointerDownId: null,\n      startTime: null,\n      prevOffsetX: 0,\n      prevOffsetY: 0\n    };\n  }, []);\n\n  const panProps = isDisabled\n    ? {}\n    : {\n        /** event handlers to spread on the target element. */\n        onPointerDown,\n        onPointerUp,\n        onPointerMove,\n        onPointerCancel: clearPan\n      };\n\n  return {\n    panProps\n  };\n}\n"],"names":["onPan","threshold","minimumTime","isDisabled","ref","useRef","pointerDownId","startTime","prevOffsetX","prevOffsetY","onPointerDown","useCallback","e","current","clearPan","pointerId","timeStamp","offsetX","offsetY","x","clientX","y","clientY","status","onPointerUp","ev","horizontalThreshold","verticalThreshold","Math","abs","panProps","onPointerMove","onPointerCancel"],"mappings":"gFAiCEA,GACAC,UAAEA,EAAY,GAAdC,YAAkBA,EAAc,IAAhCC,WAAqCA,GAAa,GAAsB,CACtEF,UAAW,GACXC,YAAa,IACbC,YAAY,IAGd,MAAMC,EAAMC,EAAAA,OAAiB,CAC3BC,cAAe,EACfC,UAAW,EACXC,YAAa,EACbC,YAAa,IAGTC,EAAgBC,eAAaC,IAC5BR,EAAIS,QAAQP,cASfQ,KARAV,EAAIS,QAAU,CACZP,cAAeM,EAAEG,UACjBR,UAAWK,EAAEI,UACbR,YAAaI,EAAEK,QACfR,YAAaG,EAAEM,SAEjBlB,MAAAA,GAAAA,EAAQ,CAAEmB,EAAGP,EAAEQ,QAASC,EAAGT,EAAEU,QAASC,OAAQ,aAI/C,IAQGC,EAAcb,eACjBc,IACC,GAAIA,EAAGV,YAAcX,EAAIS,QAAQP,eAC3BF,EAAIS,QAAQN,WAAakB,EAAGT,UAAYZ,EAAIS,QAAQN,WAAaL,EAAa,CAChF,MAAMwB,EAAsBD,EAAGR,QAAUb,EAAIS,QAAQL,YAC/CmB,EAAoBF,EAAGP,QAAUd,EAAIS,QAAQJ,YAC/CmB,KAAKC,IAAIH,GAAuBE,KAAKC,IAAIF,IAEvCvB,EAAIS,QAAQL,YAAciB,EAAGR,QAAUhB,GAEhCwB,EAAGR,QAAUb,EAAIS,QAAQL,YAAcP,KADhDD,MAAAA,GAAAA,EAAQ,CAAEmB,EAAGM,EAAGL,QAASC,EAAGI,EAAGH,QAASC,OAAQ,UAM9CnB,EAAIS,QAAQJ,YAAcgB,EAAGP,QAAUjB,GAEhCwB,EAAGP,QAAUd,EAAIS,QAAQJ,YAAcR,KADhDD,MAAAA,GAAAA,EAAQ,CAAEmB,EAAGM,EAAGL,QAASC,EAAGI,EAAGH,QAASC,OAAQ,SAQxDT,MAEF,CAACb,EAAWD,IAGRc,EAAWH,EAAAA,aAAY,KAC3BP,EAAIS,QAAU,CACZP,cAAe,KACfC,UAAW,KACXC,YAAa,EACbC,YAAa,KAEd,IAYH,MAAO,CACLqB,SAXe3B,EACb,GACA,CAEEO,cAAAA,EACAc,YAAAA,EACAO,cAlDiBnB,IACjBR,EAAIS,QAAQP,gBAAkBM,EAAEG,YAClCf,MAAAA,GAAAA,EAAQ,CAAEmB,EAAGP,EAAEQ,QAASC,EAAGT,EAAEU,QAASC,OAAQ,WAiD5CS,gBAAiBlB"}

package/amd/hooks/UNSAFE_usePrefixSuffix.js

@@ -0,0 +1,2 @@
+define(["exports","preact/jsx-runtime","../UNSAFE_PrefixSuffix","./UNSAFE_useUser",'module',"../utils/UNSAFE_classNames","../classNames-3c307969","preact/hooks","../UNSAFE_Environment","preact","../UNSAFE_Layer","preact/compat"],(function(e,i,s,t,n,r,a,d,o,f,u,l){"use strict";e.usePrefixSuffix=({baseId:e,hasEndContent:n,hasInsideLabel:r,hasStartContent:a,hasValue:d,isDisabled:o,isFocused:f,labelId:u,prefix:l,suffix:x,value:c})=>{const{direction:v}=t.useUser(),$=`${e}-prefix`,h=`${e}-suffix`,S=void 0!==l&&""!==l,b=void 0!==x&&""!==x,p=S&&!o&&(d||f)?i.jsx(s.PrefixSuffix,{id:$,hasEndContent:n,hasInsideLabel:r,hasStartContent:a,isDisabled:o,isFocused:f,text:l,variant:"prefix"}):void 0,E=b&&!o&&(d||f)?i.jsx(s.PrefixSuffix,{id:h,hasInsideLabel:r,isDisabled:o,isFocused:f,text:x,variant:"suffix"}):void 0,F=S||b?function(e,i,s,t,n){if(!i)return n;const r="ltr"===e,a=void 0===s?"":r?`${s} `:` ${s}`,d=void 0===t?"":r?` ${t}`:`${t} `,o=`${a}${n}${d}`,f=`${d}${n}${a}`;return r?o:f}(v,d,l,x,c):c,N=S||b?function(e,i,s){const t=null!=e?e:"",n=void 0===i?"":0===t.length?i:` ${i}`,r=void 0===s?"":0===t.length&&0===n.length?s:` ${s}`,a=`${t}${n}${r}`;return 0===a.length?void 0:a}(u,S?$:void 0,b?h:void 0):void 0;return{renderedPrefix:p,renderedSuffix:E,text:F,ariaLabelledBy:N}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_usePrefixSuffix.js.map

package/amd/hooks/UNSAFE_usePrefixSuffix.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_usePrefixSuffix.js","sources":["../../../src/hooks/UNSAFE_usePrefixSuffix/usePrefixSuffix.tsx"],"sourcesContent":["import { PrefixSuffix } from '../../UNSAFE_PrefixSuffix';\nimport { useUser } from '../UNSAFE_useUser';\n\ntype Props = {\n  baseId: string;\n  hasEndContent?: boolean;\n  hasInsideLabel?: boolean;\n  hasStartContent?: boolean;\n  hasValue?: boolean;\n  isDisabled?: boolean;\n  isFocused?: boolean;\n  labelId?: string;\n  prefix?: string;\n  suffix?: string;\n  value?: string;\n};\n\n// returns the prefix and/or suffix components\n// if the condition in which they should be shown is met.\nexport const usePrefixSuffix = ({\n  baseId,\n  hasEndContent,\n  hasInsideLabel,\n  hasStartContent,\n  hasValue,\n  isDisabled,\n  isFocused,\n  labelId,\n  prefix,\n  suffix,\n  value\n}: Props) => {\n  const { direction } = useUser();\n  // for accessibility, if you have a prefix, then you must have a prefixId\n  const prefixId = `${baseId}-prefix`;\n  const suffixId = `${baseId}-suffix`;\n  const hasPrefixText = prefix !== undefined && prefix !== '';\n  const hasSuffixText = suffix !== undefined && suffix !== '';\n\n  const renderedPrefix =\n    hasPrefixText && !isDisabled && (hasValue || isFocused) ? (\n      <PrefixSuffix\n        id={prefixId}\n        hasEndContent={hasEndContent}\n        hasInsideLabel={hasInsideLabel}\n        hasStartContent={hasStartContent}\n        isDisabled={isDisabled}\n        isFocused={isFocused}\n        text={prefix}\n        variant=\"prefix\"\n      />\n    ) : undefined;\n\n  const renderedSuffix =\n    hasSuffixText && !isDisabled && (hasValue || isFocused) ? (\n      <PrefixSuffix\n        id={suffixId}\n        hasInsideLabel={hasInsideLabel}\n        isDisabled={isDisabled}\n        isFocused={isFocused}\n        text={suffix}\n        variant=\"suffix\"\n      />\n    ) : undefined;\n\n  // get value and prefix/suffix if available and return as plain text.\n  const text =\n    hasPrefixText || hasSuffixText ? getText(direction, hasValue, prefix, suffix, value) : value;\n  // get aria-labelledby if there is a prefix or suffix\n  const ariaLabelledBy =\n    hasPrefixText || hasSuffixText\n      ? getAriaLabelledBy(\n          labelId,\n          hasPrefixText ? prefixId : undefined,\n          hasSuffixText ? suffixId : undefined\n        )\n      : undefined;\n\n  return { renderedPrefix, renderedSuffix, text, ariaLabelledBy };\n};\n\n/**\n * Returns the value to render in plain text, taking into account the prefix and suffix\n * and reading direction. Do not add a prefix/suffix if the component doesn't have a value.\n * @returns string | undefined\n */\nfunction getText(\n  direction: 'ltr' | 'rtl',\n  hasValue?: boolean,\n  prefix?: string,\n  suffix?: string,\n  value?: string\n) {\n  // Do not add a prefix/suffix if the component doesn't have a value.\n  if (!hasValue) {\n    return value;\n  }\n  // TODO: direction is 'ltr' even though the storybook is rtl.\n  // Test this when the storybook bug is fixed. https://jira.oraclecorp.com/jira/browse/JET-51816?src=confmacro\n  const isLTR = direction === 'ltr';\n  const plainPrefix = prefix === undefined ? `` : isLTR ? `${prefix} ` : ` ${prefix}`;\n  const plainSuffix = suffix === undefined ? `` : isLTR ? ` ${suffix}` : `${suffix} `;\n\n  const ltrPlainText = `${plainPrefix}${value}${plainSuffix}`;\n  const rtlPlainText = `${plainSuffix}${value}${plainPrefix}`;\n  return isLTR ? ltrPlainText : rtlPlainText;\n}\n\nfunction getAriaLabelledBy(labelId?: string, prefixId?: string, suffixId?: string) {\n  const label = labelId ?? '';\n  const prefix = prefixId === undefined ? '' : label.length === 0 ? prefixId : ` ${prefixId}`;\n  const suffix =\n    suffixId === undefined\n      ? ''\n      : label.length === 0 && prefix.length === 0\n      ? suffixId\n      : ` ${suffixId}`;\n  const ariaLabelledBy = `${label}${prefix}${suffix}`;\n  return ariaLabelledBy.length === 0 ? undefined : ariaLabelledBy;\n}\n"],"names":["baseId","hasEndContent","hasInsideLabel","hasStartContent","hasValue","isDisabled","isFocused","labelId","prefix","suffix","value","direction","useUser","prefixId","suffixId","hasPrefixText","undefined","hasSuffixText","renderedPrefix","_jsx","jsx","PrefixSuffix","id","text","variant","renderedSuffix","isLTR","plainPrefix","plainSuffix","ltrPlainText","rtlPlainText","getText","ariaLabelledBy","label","length","getAriaLabelledBy"],"mappings":"wSAmB+B,EAC7BA,OAAAA,EACAC,cAAAA,EACAC,eAAAA,EACAC,gBAAAA,EACAC,SAAAA,EACAC,WAAAA,EACAC,UAAAA,EACAC,QAAAA,EACAC,OAAAA,EACAC,OAAAA,EACAC,MAAAA,MAEA,MAAMC,UAAEA,GAAcC,EAAAA,UAEhBC,EAAc,GAAAb,WACdc,EAAc,GAAAd,WACde,OAA2BC,IAAXR,GAAmC,KAAXA,EACxCS,OAA2BD,IAAXP,GAAmC,KAAXA,EAExCS,EACJH,IAAkBV,IAAeD,GAAYE,GAC3Ca,EAACC,IAAAC,EAAYA,aACX,CAAAC,GAAIT,EACJZ,cAAeA,EACfC,eAAgBA,EAChBC,gBAAiBA,EACjBE,WAAYA,EACZC,UAAWA,EACXiB,KAAMf,EACNgB,QAAQ,gBAERR,EAEAS,EACJR,IAAkBZ,IAAeD,GAAYE,GAC3Ca,MAACE,EAAAA,aACC,CAAAC,GAAIR,EACJZ,eAAgBA,EAChBG,WAAYA,EACZC,UAAWA,EACXiB,KAAMd,EACNe,QAAQ,gBAERR,EAGAO,EACJR,GAAiBE,EAmBrB,SACEN,EACAP,EACAI,EACAC,EACAC,GAGA,IAAKN,EACH,OAAOM,EAIT,MAAMgB,EAAsB,QAAdf,EACRgB,OAAyBX,IAAXR,EAAyB,GAAGkB,EAAQ,GAAGlB,KAAY,IAAIA,IACrEoB,OAAyBZ,IAAXP,EAAyB,GAAGiB,EAAQ,IAAIjB,IAAW,GAAGA,KAEpEoB,EAAkB,GAAAF,IAAcjB,IAAQkB,IACxCE,EAAkB,GAAAF,IAAclB,IAAQiB,IAC9C,OAAOD,EAAQG,EAAeC,EAtCKC,CAAQpB,EAAWP,EAAUI,EAAQC,EAAQC,GAASA,EAEnFsB,EACJjB,GAAiBE,EAsCrB,SAA2BV,EAAkBM,EAAmBC,GAC9D,MAAMmB,EAAQ1B,MAAAA,EAAAA,EAAW,GACnBC,OAAsBQ,IAAbH,EAAyB,GAAsB,IAAjBoB,EAAMC,OAAerB,EAAW,IAAIA,IAC3EJ,OACSO,IAAbF,EACI,GACiB,IAAjBmB,EAAMC,QAAkC,IAAlB1B,EAAO0B,OAC7BpB,EACA,IAAIA,IACJkB,EAAoB,GAAAC,IAAQzB,IAASC,IAC3C,OAAiC,IAA1BuB,EAAeE,YAAelB,EAAYgB,EA/C3CG,CACE5B,EACAQ,EAAgBF,OAAWG,EAC3BC,EAAgBH,OAAWE,QAE7BA,EAEN,MAAO,CAAEE,eAAAA,EAAgBO,eAAAA,EAAgBF,KAAAA,EAAMS,eAAAA"}

package/amd/hooks/UNSAFE_usePress.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,t){"use strict";const a={isDisabled:!1,isRepeat:!1,repeatDelay:500,repeatInterval:40};e.usePress=function(e,r=a){const n=Object.assign(Object.assign({},a),r),[s,c]=t.useState(!0),[l,o]=t.useState(!1),u=t.useRef(),p=t.useRef(!1),i=t=>{p.current&&e(t),u.current=setInterval(e,n.repeatInterval,t)},R=t.useCallback((t=>{"Space"!==t.code&&"Enter"!==t.code||!n.isRepeat&&t.repeat||(t.preventDefault(),o(!0),n.isRepeat&&e(t))}),[n.isRepeat,e,o]),b=t.useCallback((t=>{"Space"!==t.code&&"Enter"!==t.code||(o(!1),t.preventDefault(),n.isRepeat||e(t))}),[n.isRepeat,e,o]),C=t.useCallback((()=>{o(!1)}),[o]),k=t.useCallback((t=>{c(!1),n.isRepeat&&(p.current=!0,t.preventDefault(),e(t),u.current=setTimeout(i,n.repeatDelay,t))}),[n,e,u,c,i]),v=t.useCallback((t=>{n.isRepeat&&u.current?(p.current=!1,clearInterval(u.current),u.current=void 0):e(t)}),[n.isRepeat,u,e]),D=t.useCallback((t=>{t.stopPropagation(),s&&!l&&u.current&&e(t),c(!0)}),[c,e,s,u,l]),d=t.useCallback((t=>{t.stopPropagation(),l||e(t)}),[e,l]),f=t.useCallback((()=>{c(!0),n.isRepeat&&u.current&&clearInterval(u.current)}),[n.isRepeat,e,u,c]),P=t.useCallback((()=>{c(!0),n.isRepeat&&u.current&&clearInterval(u.current)}),[n.isRepeat,e,u,c]),y=t.useCallback((e=>{c(!0),n.isRepeat&&e.preventDefault()}),[n.isRepeat,e,c]);return{pressProps:n.isDisabled?{}:n.isRepeat?{onPointerUp:v,onPointerDown:k,onPointerOut:f,onPointerCancel:P,onKeyDown:R,onKeyUp:b,onContextMenu:y,onClick:D,onBlur:C}:{onKeyDown:R,onKeyUp:b,onBlur:C,onClick:d}}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_usePress.js.map

package/amd/hooks/UNSAFE_usePress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_usePress.js","sources":["../../../src/hooks/UNSAFE_usePress/usePress.ts"],"sourcesContent":["import { useCallback, useState, useRef } from 'preact/hooks';\n\nexport type PressOptions = {\n  isDisabled?: boolean;\n  isRepeat?: boolean;\n  repeatDelay?: number;\n  repeatInterval?: number;\n};\n\nconst DefaultSettings = {\n  isDisabled: false,\n  isRepeat: false,\n  repeatDelay: 500,\n  repeatInterval: 40\n};\n\n/**\n * Returns a click handler that can make a target element either clickable or keyboard pressable.\n *\n * @param onPressHandler function\n * @param isRepeat boolean\n * @param repeatInterval number number of ms between events for mouse and touch\n * @param repeatDelay number number of ms before repeat events initiates\n * @param isDisabled boolean\n * @returns\n */\n\nexport function usePress(\n  onPressHandler: (event: Event) => void,\n  settings: PressOptions = DefaultSettings\n): { pressProps: Record<string, any> } {\n  const mergedSettings = { ...DefaultSettings, ...settings };\n  const [isClickable, setIsClickable] = useState<boolean>(true);\n  const [isPressed, setIsPressed] = useState<boolean>(false);\n  const intervalID = useRef<ReturnType<typeof setInterval>>();\n  const isRepeating = useRef<boolean>(false);\n  const repeatHandler = (event: Event) => {\n    if (isRepeating.current) {\n      onPressHandler(event);\n    }\n    intervalID.current = setInterval(onPressHandler, mergedSettings.repeatInterval, event); // @HTMLUpdateOK\n  };\n\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (\n        (event.code === 'Space' || event.code === 'Enter') &&\n        (mergedSettings.isRepeat || !event.repeat)\n      ) {\n        event.preventDefault();\n        setIsPressed(true);\n        if (mergedSettings.isRepeat) {\n          onPressHandler(event);\n        }\n      }\n    },\n    [mergedSettings.isRepeat, onPressHandler, setIsPressed]\n  );\n\n  const onKeyUp = useCallback(\n    (event: KeyboardEvent) => {\n      if (event.code === 'Space' || event.code === 'Enter') {\n        setIsPressed(false);\n        event.preventDefault();\n        if (!mergedSettings.isRepeat) {\n          onPressHandler(event);\n        }\n      }\n    },\n    [mergedSettings.isRepeat, onPressHandler, setIsPressed]\n  );\n\n  const onBlur = useCallback(() => {\n    setIsPressed(false);\n  }, [setIsPressed]);\n\n  const onPointerDown = useCallback(\n    (event: PointerEvent) => {\n      setIsClickable(false);\n      if (mergedSettings.isRepeat) {\n        isRepeating.current = true;\n        event.preventDefault();\n        onPressHandler(event);\n        intervalID.current = setTimeout(repeatHandler, mergedSettings.repeatDelay, event);\n      }\n    },\n    [mergedSettings, onPressHandler, intervalID, setIsClickable, repeatHandler]\n  );\n\n  const onPointerUp = useCallback(\n    (event: PointerEvent) => {\n      if (mergedSettings.isRepeat && intervalID.current) {\n        isRepeating.current = false;\n        clearInterval(intervalID.current);\n        intervalID.current = undefined;\n      } else {\n        onPressHandler(event);\n      }\n    },\n    [mergedSettings.isRepeat, intervalID, onPressHandler]\n  );\n\n  // Keep this to permit automated invocation of target via click event\n  // Need to ignore this for manual invocation whereby browser generates click\n  // pointerdown/pointerup/click -> ignore click\n  // keydown/keyup/click -> ignore click\n  // click without pointerup or keyup -> invoke\n  const onClick = useCallback(\n    (event: Event) => {\n      // There are use cases where pressable/clickable components (eg. Buttons) are nested inside of other\n      // components that also process bubbling click events (eg. Collapsible). In order to avoid conflicting\n      // processing of clicks (eg. in order to avoid the click both activating a Button as well as toggling the\n      // ancestor Collapsible), we stop propagation here. That way, only the child component handles the\n      // click and the ancestor component is oblivious to the fact that the click even occurred.\n      event.stopPropagation();\n      if (isClickable && !isPressed && intervalID.current) {\n        onPressHandler(event);\n      }\n      setIsClickable(true);\n    },\n    [setIsClickable, onPressHandler, isClickable, intervalID, isPressed]\n  );\n\n  const onClickSingle = useCallback(\n    (event: Event) => {\n      // See note above about why propagation is stopped: to prevent nested component bubbling clicks issue\n      event.stopPropagation();\n      if (!isPressed) {\n        onPressHandler(event);\n      }\n    },\n    [onPressHandler, isPressed]\n  );\n\n  const onPointerOut = useCallback(() => {\n    setIsClickable(true);\n    if (mergedSettings.isRepeat && intervalID.current) {\n      clearInterval(intervalID.current);\n    }\n  }, [mergedSettings.isRepeat, onPressHandler, intervalID, setIsClickable]);\n\n  const onPointerCancel = useCallback(() => {\n    setIsClickable(true);\n    if (mergedSettings.isRepeat && intervalID.current) {\n      clearInterval(intervalID.current);\n    }\n  }, [mergedSettings.isRepeat, onPressHandler, intervalID, setIsClickable]);\n\n  const onContextMenu = useCallback(\n    (event: PointerEvent) => {\n      setIsClickable(true);\n      if (mergedSettings.isRepeat) {\n        event.preventDefault();\n      }\n    },\n    [mergedSettings.isRepeat, onPressHandler, setIsClickable]\n  );\n\n  const pressProps = mergedSettings.isDisabled\n    ? {}\n    : mergedSettings.isRepeat\n    ? {\n        onPointerUp,\n        onPointerDown,\n        onPointerOut,\n        onPointerCancel,\n        onKeyDown,\n        onKeyUp,\n        onContextMenu,\n        onClick,\n        onBlur\n      }\n    : {\n        onKeyDown,\n        onKeyUp,\n        onBlur,\n        onClick: onClickSingle\n      };\n\n  return {\n    pressProps\n  };\n}\n"],"names":["DefaultSettings","isDisabled","isRepeat","repeatDelay","repeatInterval","onPressHandler","settings","mergedSettings","Object","assign","isClickable","setIsClickable","useState","isPressed","setIsPressed","intervalID","useRef","isRepeating","repeatHandler","event","current","setInterval","onKeyDown","useCallback","code","repeat","preventDefault","onKeyUp","onBlur","onPointerDown","setTimeout","onPointerUp","clearInterval","undefined","onClick","stopPropagation","onClickSingle","onPointerOut","onPointerCancel","onContextMenu","pressProps"],"mappings":"8DASA,MAAMA,EAAkB,CACtBC,YAAY,EACZC,UAAU,EACVC,YAAa,IACbC,eAAgB,wBAehBC,EACAC,EAAyBN,GAEzB,MAAMO,EAAsBC,OAAAC,OAAAD,OAAAC,OAAA,GAAAT,GAAoBM,IACzCI,EAAaC,GAAkBC,EAAQA,UAAU,IACjDC,EAAWC,GAAgBF,EAAQA,UAAU,GAC9CG,EAAaC,EAAAA,SACbC,EAAcD,UAAgB,GAC9BE,EAAiBC,IACjBF,EAAYG,SACdf,EAAec,GAEjBJ,EAAWK,QAAUC,YAAYhB,EAAgBE,EAAeH,eAAgBe,IAG5EG,EAAYC,eACfJ,IAEmB,UAAfA,EAAMK,MAAmC,UAAfL,EAAMK,OAChCjB,EAAeL,UAAaiB,EAAMM,SAEnCN,EAAMO,iBACNZ,GAAa,GACTP,EAAeL,UACjBG,EAAec,MAIrB,CAACZ,EAAeL,SAAUG,EAAgBS,IAGtCa,EAAUJ,eACbJ,IACoB,UAAfA,EAAMK,MAAmC,UAAfL,EAAMK,OAClCV,GAAa,GACbK,EAAMO,iBACDnB,EAAeL,UAClBG,EAAec,MAIrB,CAACZ,EAAeL,SAAUG,EAAgBS,IAGtCc,EAASL,EAAAA,aAAY,KACzBT,GAAa,KACZ,CAACA,IAEEe,EAAgBN,eACnBJ,IACCR,GAAe,GACXJ,EAAeL,WACjBe,EAAYG,SAAU,EACtBD,EAAMO,iBACNrB,EAAec,GACfJ,EAAWK,QAAUU,WAAWZ,EAAeX,EAAeJ,YAAagB,MAG/E,CAACZ,EAAgBF,EAAgBU,EAAYJ,EAAgBO,IAGzDa,EAAcR,eACjBJ,IACKZ,EAAeL,UAAYa,EAAWK,SACxCH,EAAYG,SAAU,EACtBY,cAAcjB,EAAWK,SACzBL,EAAWK,aAAUa,GAErB5B,EAAec,KAGnB,CAACZ,EAAeL,SAAUa,EAAYV,IAQlC6B,EAAUX,eACbJ,IAMCA,EAAMgB,kBACFzB,IAAgBG,GAAaE,EAAWK,SAC1Cf,EAAec,GAEjBR,GAAe,KAEjB,CAACA,EAAgBN,EAAgBK,EAAaK,EAAYF,IAGtDuB,EAAgBb,eACnBJ,IAECA,EAAMgB,kBACDtB,GACHR,EAAec,KAGnB,CAACd,EAAgBQ,IAGbwB,EAAed,EAAAA,aAAY,KAC/BZ,GAAe,GACXJ,EAAeL,UAAYa,EAAWK,SACxCY,cAAcjB,EAAWK,WAE1B,CAACb,EAAeL,SAAUG,EAAgBU,EAAYJ,IAEnD2B,EAAkBf,EAAAA,aAAY,KAClCZ,GAAe,GACXJ,EAAeL,UAAYa,EAAWK,SACxCY,cAAcjB,EAAWK,WAE1B,CAACb,EAAeL,SAAUG,EAAgBU,EAAYJ,IAEnD4B,EAAgBhB,eACnBJ,IACCR,GAAe,GACXJ,EAAeL,UACjBiB,EAAMO,mBAGV,CAACnB,EAAeL,SAAUG,EAAgBM,IAwB5C,MAAO,CACL6B,WAtBiBjC,EAAeN,WAC9B,GACAM,EAAeL,SACf,CACE6B,YAAAA,EACAF,cAAAA,EACAQ,aAAAA,EACAC,gBAAAA,EACAhB,UAAAA,EACAK,QAAAA,EACAY,cAAAA,EACAL,QAAAA,EACAN,OAAAA,GAEF,CACEN,UAAAA,EACAK,QAAAA,EACAC,OAAAA,EACAM,QAASE"}

package/amd/hooks/UNSAFE_useScale.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks","../UNSAFE_Environment","preact","preact/jsx-runtime","../UNSAFE_Layer","preact/compat"],(function(e,t,n,r,o,c,a){"use strict";e.useScale=function(){return t.useContext(n.EnvironmentContext).scale},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useScale.js.map

package/amd/hooks/UNSAFE_useScale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UNSAFE_useScale.js","sources":["../../../src/hooks/UNSAFE_useScale/useScale.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 useScale() {\n  return useContext(EnvironmentContext).scale;\n}\n"],"names":["useContext","EnvironmentContext","scale"],"mappings":"sLAWE,OAAOA,EAAUA,WAACC,sBAAoBC"}

package/amd/hooks/UNSAFE_useSwipe.js

@@ -0,0 +1,2 @@
+define(["exports","preact/hooks"],(function(e,t){"use strict";e.useSwipe=function(e,{threshold:r=10,maximumTime:o=300,tolerance:n=50,isDisabled:f=!1}={threshold:10,maximumTime:300,tolerance:50,isDisabled:!1}){const s=t.useRef({pointerDownId:0,startTime:null,prevoffsetX:0,prevoffsetY:0}),i=t.useCallback((e=>{s.current.pointerDownId?p():s.current={pointerDownId:e.pointerId,startTime:e.timeStamp,prevoffsetX:e.offsetX,prevoffsetY:e.offsetY}}),[]),u=t.useCallback((t=>{t.pointerId===s.current.pointerDownId&&s.current.startTime&&t.timeStamp-s.current.startTime<o&&(s.current.prevoffsetX-t.offsetX>r&&Math.abs(t.offsetY-s.current.prevoffsetY)<=n?null==e||e({direction:"left"}):t.offsetX-s.current.prevoffsetX>r&&Math.abs(t.offsetY-s.current.prevoffsetY)<=n?null==e||e({direction:"right"}):s.current.prevoffsetY-t.offsetY>r&&Math.abs(t.offsetX-s.current.prevoffsetX)<=n?null==e||e({direction:"up"}):t.offsetY-s.current.prevoffsetY>r&&Math.abs(t.offsetX-s.current.prevoffsetX)<=n&&(null==e||e({direction:"down"}))),p()}),[r,e]),p=t.useCallback((()=>{s.current={pointerDownId:null,startTime:0,prevoffsetX:0,prevoffsetY:0}}),[]);return{swipeProps:f?{}:{onPointerDown:i,onPointerUp:u,onPointerCancel:p}}},Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=UNSAFE_useSwipe.js.map