@hina-ui/vue 1.7.12 → 1.7.14

package/dist/shared/primitives/popper/index.ts

@@ -0,0 +1,246 @@
+import {
+  arrow,
+  flip,
+  hide,
+  limitShift,
+  offset,
+  shift,
+  size,
+  type Boundary,
+  type Middleware,
+  type MiddlewareData,
+  type Padding,
+  type Placement,
+} from '@floating-ui/dom'
+
+const SIDE_OPTIONS = ['top', 'right', 'bottom', 'left'] as const
+const ALIGN_OPTIONS = ['start', 'center', 'end'] as const
+
+export type Side = (typeof SIDE_OPTIONS)[number]
+export type Align = (typeof ALIGN_OPTIONS)[number]
+export type Direction = 'ltr' | 'rtl'
+
+export function isNotNull<T>(value: T | null): value is T {
+  return value !== null
+}
+
+export function transformOrigin(options: {
+  arrowWidth: number
+  arrowHeight: number
+  dir?: Direction
+}): Middleware {
+  return {
+    name: 'transformOrigin',
+    options,
+    fn(data) {
+      const { placement, rects, middlewareData } = data
+
+      const cannotCenterArrow = middlewareData.arrow?.centerOffset !== 0
+      const isArrowHidden = cannotCenterArrow
+      const arrowWidth = isArrowHidden ? 0 : options.arrowWidth
+      const arrowHeight = isArrowHidden ? 0 : options.arrowHeight
+
+      const [placedSide, placedAlign] = getSideAndAlignFromPlacement(placement)
+      const noArrowAlignX = {
+        start: options.dir === 'rtl' ? '100%' : '0%',
+        center: '50%',
+        end: options.dir === 'rtl' ? '0%' : '100%',
+      }[placedAlign]
+
+      const noArrowAlignY = {
+        start: '0%',
+        center: '50%',
+        end: '100%',
+      }[placedAlign]
+
+      const arrowXCenter = (middlewareData.arrow?.x ?? 0) + arrowWidth / 2
+      const arrowYCenter = (middlewareData.arrow?.y ?? 0) + arrowHeight / 2
+
+      let x = ''
+      let y = ''
+
+      if (placedSide === 'bottom') {
+        x = isArrowHidden ? noArrowAlignX : `${arrowXCenter}px`
+        y = `${-arrowHeight}px`
+      } else if (placedSide === 'top') {
+        x = isArrowHidden ? noArrowAlignX : `${arrowXCenter}px`
+        y = `${rects.floating.height + arrowHeight}px`
+      } else if (placedSide === 'right') {
+        x = `${-arrowHeight}px`
+        y = isArrowHidden ? noArrowAlignY : `${arrowYCenter}px`
+      } else if (placedSide === 'left') {
+        x = `${rects.floating.width + arrowHeight}px`
+        y = isArrowHidden ? noArrowAlignY : `${arrowYCenter}px`
+      }
+      return { data: { x, y } }
+    },
+  }
+}
+
+export function getSideAndAlignFromPlacement(placement: Placement) {
+  const [side, align = 'center'] = placement.split('-')
+  return [side as Side, align as Align] as const
+}
+
+export type PopperSticky = 'partial' | 'always'
+export type PopperStrategy = 'absolute' | 'fixed'
+export type PopperUpdateStrategy = 'optimized' | 'always'
+
+export const POPPER_CONTENT_DEFAULTS = {
+  side: 'bottom' as Side,
+  sideOffset: 0,
+  sideFlip: true,
+  align: 'center' as Align,
+  alignOffset: 0,
+  alignFlip: true,
+  arrowPadding: 0,
+  hideShiftedArrow: true,
+  avoidCollisions: true,
+  collisionBoundary: () => [] as Element[],
+  collisionPadding: 0,
+  sticky: 'partial' as PopperSticky,
+  hideWhenDetached: false,
+  positionStrategy: 'fixed' as PopperStrategy,
+  updatePositionStrategy: 'optimized' as PopperUpdateStrategy,
+  prioritizePosition: false,
+}
+
+export function popperPlacement(side: Side, align: Align) {
+  return (side + (align !== 'center' ? `-${align}` : '')) as Placement
+}
+
+export interface PopperMiddlewareOptions {
+  sideOffset: number
+  alignOffset: number
+  sideFlip: boolean
+  alignFlip: boolean
+  avoidCollisions: boolean
+  prioritizePosition: boolean
+  sticky: PopperSticky
+  collisionPadding: number | Partial<Record<Side, number>>
+  collisionBoundary: Element | null | Array<Element | null>
+  arrow: HTMLElement | null | undefined
+  arrowWidth: number
+  arrowHeight: number
+  arrowPadding: number
+  hideWhenDetached: boolean
+  dir: Direction
+  prefix: 'reka' | 'radix'
+}
+
+export function popperMiddleware(options: PopperMiddlewareOptions) {
+  const padding: Padding =
+    typeof options.collisionPadding === 'number'
+      ? options.collisionPadding
+      : { top: 0, right: 0, bottom: 0, left: 0, ...options.collisionPadding }
+  const boundary = Array.isArray(options.collisionBoundary)
+    ? options.collisionBoundary
+    : [options.collisionBoundary]
+  const detectOverflowOptions = {
+    padding,
+    boundary: boundary.filter(isNotNull) as Boundary,
+    altBoundary: boundary.length > 0,
+  }
+  const flipOptions = { mainAxis: options.sideFlip, crossAxis: options.alignFlip }
+  const { prefix } = options
+  return [
+    offset({
+      mainAxis: options.sideOffset + options.arrowHeight,
+      alignmentAxis: options.alignOffset,
+    }),
+    options.prioritizePosition &&
+      options.avoidCollisions &&
+      flip({ ...detectOverflowOptions, ...flipOptions }),
+    options.avoidCollisions &&
+      shift({
+        mainAxis: true,
+        crossAxis: !!options.prioritizePosition,
+        limiter: options.sticky === 'partial' ? limitShift() : undefined,
+        ...detectOverflowOptions,
+      }),
+    !options.prioritizePosition &&
+      options.avoidCollisions &&
+      flip({ ...detectOverflowOptions, ...flipOptions }),
+    size({
+      ...detectOverflowOptions,
+      apply: ({ elements, rects, availableWidth, availableHeight }) => {
+        const { width: anchorWidth, height: anchorHeight } = rects.reference
+        const contentStyle = elements.floating.style
+        contentStyle.setProperty(`--${prefix}-popper-available-width`, `${availableWidth}px`)
+        contentStyle.setProperty(`--${prefix}-popper-available-height`, `${availableHeight}px`)
+        contentStyle.setProperty(`--${prefix}-popper-anchor-width`, `${anchorWidth}px`)
+        contentStyle.setProperty(`--${prefix}-popper-anchor-height`, `${anchorHeight}px`)
+      },
+    }),
+    options.arrow && arrow({ element: options.arrow, padding: options.arrowPadding }),
+    transformOrigin({
+      arrowWidth: options.arrowWidth,
+      arrowHeight: options.arrowHeight,
+      dir: options.dir,
+    }),
+    options.hideWhenDetached && hide({ strategy: 'referenceHidden', ...detectOverflowOptions }),
+  ] as Middleware[]
+}
+
+export function popperWrapperStyle(
+  floatingStyles: object & { transform?: unknown },
+  options: {
+    isPositioned: boolean
+    zIndex: string
+    middlewareData: MiddlewareData
+    prefix: 'reka' | 'radix'
+  },
+) {
+  const { isPositioned, zIndex, middlewareData, prefix } = options
+  return {
+    ...floatingStyles,
+    transform: isPositioned ? floatingStyles.transform : 'translate(0, -200%)',
+    minWidth: 'max-content',
+    zIndex,
+    [`--${prefix}-popper-transform-origin`]: [
+      middlewareData.transformOrigin?.x,
+      middlewareData.transformOrigin?.y,
+    ].join(' '),
+    ...(middlewareData.hide?.referenceHidden && {
+      visibility: 'hidden',
+      pointerEvents: 'none',
+    }),
+  }
+}
+
+export function shouldHidePopperArrow(hideShiftedArrow: boolean, middlewareData: MiddlewareData) {
+  return hideShiftedArrow && middlewareData.arrow?.centerOffset !== 0
+}
+
+export const OPPOSITE_SIDE: Record<Side, Side> = {
+  top: 'bottom',
+  right: 'left',
+  bottom: 'top',
+  left: 'right',
+}
+
+export const ARROW_PATH = 'M0 0L6 6L12 0'
+export const ROUNDED_ARROW_PATH =
+  'M0 0L4.58579 4.58579C5.36683 5.36683 6.63316 5.36684 7.41421 4.58579L12 0'
+
+export function popperArrowStyle(
+  placedSide: Side,
+  arrowX: number | undefined,
+  arrowY: number | undefined,
+  hidden: boolean,
+) {
+  return {
+    position: 'absolute',
+    left: arrowX ? `${arrowX}px` : undefined,
+    top: arrowY ? `${arrowY}px` : undefined,
+    [OPPOSITE_SIDE[placedSide]]: 0,
+    transformOrigin: { top: '', right: '0 0', bottom: 'center 0', left: '100% 0' }[placedSide],
+    transform: {
+      top: 'translateY(100%)',
+      right: 'translateY(50%) rotate(90deg) translateX(-50%)',
+      bottom: 'rotate(180deg)',
+      left: 'translateY(50%) rotate(-90deg) translateX(50%)',
+    }[placedSide],
+    visibility: hidden ? 'hidden' : undefined,
+  } as const
+}

package/dist/shared/primitives/select/index.ts

@@ -0,0 +1,98 @@
+import { compare, type Comparator } from '../listbox'
+
+export const OPEN_KEYS = [' ', 'Enter', 'ArrowUp', 'ArrowDown']
+export const SELECTION_KEYS = [' ', 'Enter']
+export const CONTENT_MARGIN = 10
+export const SELECT_SELECT = 'select.select'
+
+export function isNullish(value: unknown): value is null | undefined {
+  return value === null || value === undefined
+}
+
+export function shouldShowPlaceholder(value: unknown) {
+  return (
+    value === undefined ||
+    value === null ||
+    value === '' ||
+    (Array.isArray(value) && value.length === 0)
+  )
+}
+
+export function toggleSelectValue<T>(current: unknown, value: T, by?: Comparator<T>) {
+  const array = Array.isArray(current) ? [...(current as T[])] : []
+  const index = array.findIndex(item => compare(item, value, by))
+  if (index === -1) array.push(value)
+  else array.splice(index, 1)
+  return [...array]
+}
+
+export function selectNavigationCandidates(
+  items: HTMLElement[],
+  key: string,
+  target: EventTarget | null,
+) {
+  if (!['ArrowUp', 'ArrowDown', 'Home', 'End'].includes(key)) return null
+  let candidateNodes = [...items]
+  if (['ArrowUp', 'End'].includes(key)) candidateNodes = candidateNodes.slice().reverse()
+  if (['ArrowUp', 'ArrowDown'].includes(key)) {
+    const currentIndex = candidateNodes.indexOf(target as HTMLElement)
+    candidateNodes = candidateNodes.slice(currentIndex + 1)
+  }
+  return candidateNodes
+}
+
+export interface TriggerReleaseOptions {
+  content: HTMLElement
+  origin: () => { x: number; y: number } | null | undefined
+  onOutsideRelease: () => void
+  onRelease: () => void
+}
+
+export function trackTriggerRelease(options: TriggerReleaseOptions) {
+  let pointerMoveDelta = { x: 0, y: 0 }
+  const handlePointerMove = (event: PointerEvent) => {
+    const origin = options.origin()
+    pointerMoveDelta = {
+      x: Math.abs(Math.round(event.pageX) - (origin?.x ?? 0)),
+      y: Math.abs(Math.round(event.pageY) - (origin?.y ?? 0)),
+    }
+  }
+  const handlePointerUp = (event: PointerEvent) => {
+    if (event.pointerType === 'touch') return
+    if (pointerMoveDelta.x <= 10 && pointerMoveDelta.y <= 10) event.preventDefault()
+    else if (!options.content.contains(event.target as Node)) options.onOutsideRelease()
+    document.removeEventListener('pointermove', handlePointerMove)
+    options.onRelease()
+  }
+  if (options.origin() !== null) {
+    document.addEventListener('pointermove', handlePointerMove)
+    document.addEventListener('pointerup', handlePointerUp, { capture: true, once: true })
+  }
+  return () => {
+    document.removeEventListener('pointermove', handlePointerMove)
+    document.removeEventListener('pointerup', handlePointerUp, { capture: true })
+  }
+}
+
+export function createSelectedItemTracker() {
+  let firstValidItemFound = false
+  let firstSelectedItemInArrayFound = false
+  return {
+    item(isSelected: boolean, disabled: boolean | undefined, multiple: boolean) {
+      const isFirstValidItem = !firstValidItemFound && !disabled
+      let picked = false
+      if (multiple) {
+        if (firstSelectedItemInArrayFound) return false
+        if (isSelected || isFirstValidItem) {
+          picked = true
+          if (isSelected) firstSelectedItemInArrayFound = true
+        }
+      } else if (isSelected || isFirstValidItem) picked = true
+      if (isFirstValidItem) firstValidItemFound = true
+      return picked
+    },
+    text(isSelected: boolean, disabled: boolean | undefined) {
+      return isSelected || (!firstValidItemFound && !disabled)
+    },
+  }
+}

package/dist/shared/primitives/tags-input/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/shared/primitives/tags-input/index.ts

@@ -0,0 +1,113 @@
+import { arrowNavigation } from '../arrow-navigation'
+import { isEqual } from '../value'
+
+export type AcceptableInputValue = string | number | bigint | Record<string, any>
+export type TagsInputDirection = 'ltr' | 'rtl'
+
+export function tagsInputDisplayValue(value: AcceptableInputValue) {
+  return value.toString()
+}
+
+export type TagsInputAddResult<T> =
+  { added: true; value: T[]; payload: T } | { added: false; payload: T; duplicate: boolean }
+
+export function addTagsInputValue<T extends AcceptableInputValue>(
+  model: T[] | null | undefined,
+  text: string,
+  options: {
+    duplicate: boolean
+    max: number
+    defaultValue: T[]
+    convertValue?: (value: string) => T
+  },
+): TagsInputAddResult<T> {
+  const array = Array.isArray(model) ? [...model] : []
+  const modelIsObject = array.length > 0 && typeof array[0] === 'object'
+  const defaultIsObject = array.length > 0 && typeof options.defaultValue[0] === 'object'
+  if ((modelIsObject || defaultIsObject) && typeof options.convertValue !== 'function')
+    throw new Error('You must provide a `convertValue` function when using objects as values.')
+  const payload = options.convertValue ? options.convertValue(text) : (text as T)
+  if (array.length >= options.max && !!options.max)
+    return { added: false, payload, duplicate: false }
+  if (options.duplicate || !array.includes(payload))
+    return { added: true, value: [...array, payload], payload }
+  return { added: false, payload, duplicate: true }
+}
+
+export function removeTagsInputValue<T>(model: T[], index: number) {
+  return model.filter((_, i) => i !== index)
+}
+
+export function tagsInputValueIndex<T>(model: T[], value: unknown) {
+  return model.findIndex(item => isEqual(item, value))
+}
+
+export interface TagsInputKeydownResult {
+  select?: { element: HTMLElement | undefined }
+  remove?: HTMLElement
+  preventDefault: boolean
+}
+
+export function tagsInputKeydown(
+  event: KeyboardEvent,
+  state: {
+    caretAtStart: boolean
+    items: HTMLElement[]
+    selected: HTMLElement | undefined
+    dir: TagsInputDirection
+  },
+): TagsInputKeydownResult | undefined {
+  const { items, selected, caretAtStart, dir } = state
+  if (!items.length) return
+  const lastTag = items.at(-1)
+  switch (event.key) {
+    case 'Delete':
+    case 'Backspace': {
+      if (!caretAtStart) return
+      if (selected) {
+        const index = items.findIndex(item => item === selected)
+        return {
+          remove: selected,
+          select: { element: selected === lastTag ? items.at(index - 1) : items.at(index + 1) },
+          preventDefault: true,
+        }
+      }
+      if (event.key === 'Backspace') return { select: { element: lastTag }, preventDefault: true }
+      return
+    }
+    case 'Home':
+    case 'End':
+    case 'ArrowRight':
+    case 'ArrowLeft': {
+      const isArrowRight =
+        (event.key === 'ArrowRight' && dir === 'ltr') ||
+        (event.key === 'ArrowLeft' && dir === 'rtl')
+      if (!caretAtStart) return
+      if (!isArrowRight && !selected) return { select: { element: lastTag }, preventDefault: true }
+      if (isArrowRight && lastTag && selected === lastTag)
+        return { select: { element: undefined }, preventDefault: true }
+      if (selected) {
+        const element = arrowNavigation(event, selected, undefined, {
+          itemsArray: items,
+          loop: false,
+          dir,
+        })
+        return { select: element ? { element } : undefined, preventDefault: true }
+      }
+      return
+    }
+    case 'ArrowUp':
+    case 'ArrowDown':
+      return selected ? { preventDefault: true } : undefined
+    default:
+      return { select: { element: undefined }, preventDefault: false }
+  }
+}
+
+export function matchesTagsInputDelimiter(delimiter: string | RegExp, data: string) {
+  return delimiter === data || (delimiter instanceof RegExp && delimiter.test(data))
+}
+
+export function splitTagsInputPaste(value: string, delimiter: string | RegExp) {
+  return delimiter ? value.split(delimiter) : [value]
+}

package/dist/shared/primitives/toast/LICENSE

@@ -0,0 +1,44 @@
+MIT License
+
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Portions adapted from Radix UI:
+MIT License
+
+Copyright (c) 2022 WorkOS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/shared/primitives/toast/index.ts

@@ -0,0 +1,106 @@
+import { getTabbableCandidates } from '../focus-scope'
+
+export const TOAST_SWIPE_START = 'toast.swipeStart'
+export const TOAST_SWIPE_MOVE = 'toast.swipeMove'
+export const TOAST_SWIPE_CANCEL = 'toast.swipeCancel'
+export const TOAST_SWIPE_END = 'toast.swipeEnd'
+export const VIEWPORT_PAUSE = 'toast.viewportPause'
+export const VIEWPORT_RESUME = 'toast.viewportResume'
+
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right'
+
+export interface SwipeDetail {
+  originalEvent: PointerEvent
+  delta: { x: number; y: number }
+}
+
+export type SwipeEvent = CustomEvent<SwipeDetail> & { currentTarget: HTMLElement }
+
+export function dispatchSwipeEvent(
+  name: string,
+  target: EventTarget,
+  handler: ((event: SwipeEvent) => void) | undefined,
+  detail: SwipeDetail,
+) {
+  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail })
+  if (handler) target.addEventListener(name, handler as unknown as EventListener, { once: true })
+  target.dispatchEvent(event)
+}
+
+export function isDeltaInDirection(
+  delta: { x: number; y: number },
+  direction: SwipeDirection,
+  threshold = 0,
+) {
+  const deltaX = Math.abs(delta.x)
+  const deltaY = Math.abs(delta.y)
+  const isDeltaX = deltaX > deltaY
+  if (direction === 'left' || direction === 'right') return isDeltaX && deltaX > threshold
+  return !isDeltaX && deltaY > threshold
+}
+
+export function swipeDelta(
+  start: { x: number; y: number },
+  point: { clientX: number; clientY: number },
+  direction: SwipeDirection,
+) {
+  const x = point.clientX - start.x
+  const y = point.clientY - start.y
+  const isHorizontalSwipe = ['left', 'right'].includes(direction)
+  const clamp = ['left', 'up'].includes(direction) ? Math.min : Math.max
+  return {
+    x,
+    y,
+    delta: { x: isHorizontalSwipe ? clamp(0, x) : 0, y: !isHorizontalSwipe ? clamp(0, y) : 0 },
+  }
+}
+
+export function swipeStartBuffer(pointerType: string) {
+  return pointerType === 'touch' ? 10 : 2
+}
+
+function isHTMLElement(node: Node): node is HTMLElement {
+  return node.nodeType === node.ELEMENT_NODE
+}
+
+export function getAnnounceTextContent(container: HTMLElement, prefix: 'reka' | 'radix') {
+  const textContent: string[] = []
+  const childNodes = Array.from(container.childNodes)
+  childNodes.forEach(node => {
+    if (node.nodeType === node.TEXT_NODE && node.textContent) textContent.push(node.textContent)
+    if (isHTMLElement(node)) {
+      const isHidden = node.ariaHidden || node.hidden || node.style.display === 'none'
+      const isExcluded = node.dataset[`${prefix}ToastAnnounceExclude`] === ''
+      if (!isHidden) {
+        if (isExcluded) {
+          const altText = node.dataset[`${prefix}ToastAnnounceAlt`]
+          if (altText) textContent.push(altText)
+        } else textContent.push(...getAnnounceTextContent(node, prefix))
+      }
+    }
+  })
+  return textContent
+}
+
+export function hotkeyMessage(hotkey: string[]) {
+  return hotkey.join('+').replace(/Key/g, '').replace(/Digit/g, '')
+}
+
+export function viewportLabel(label: string | ((hotkey: string) => string), hotkey: string) {
+  return typeof label === 'string' ? label.replace('{hotkey}', hotkey) : label(hotkey)
+}
+
+export function sortTabbableCandidates(
+  toasts: HTMLElement[],
+  tabbingDirection: 'forwards' | 'backwards',
+) {
+  const tabbableCandidates = toasts.map(toastNode => {
+    const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)]
+    return tabbingDirection === 'forwards'
+      ? toastTabbableCandidates
+      : toastTabbableCandidates.reverse()
+  })
+  return (
+    tabbingDirection === 'forwards' ? tabbableCandidates.reverse() : tabbableCandidates
+  ).flat()
+}

package/dist/shared/primitives/tree/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 UnoVue <https://github.com/unovue>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.