@hina-ui/vue 1.7.12 → 1.7.13

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

@@ -0,0 +1,66 @@
+import { isPointInPolygon, type Polygon } from '../grace-area'
+
+export type CheckedState = boolean | 'indeterminate'
+export type MenuDirection = 'ltr' | 'rtl'
+export type GraceSide = 'left' | 'right'
+
+export interface GraceIntent {
+  area: Polygon
+  side: GraceSide
+}
+
+export const ITEM_SELECT = 'menu.itemSelect'
+export const SELECTION_KEYS = ['Enter', ' ']
+export const FIRST_KEYS = ['ArrowDown', 'PageUp', 'Home']
+export const LAST_KEYS = ['ArrowUp', 'PageDown', 'End']
+export const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS]
+export const SUB_OPEN_KEYS: Record<MenuDirection, string[]> = {
+  ltr: [...SELECTION_KEYS, 'ArrowRight'],
+  rtl: [...SELECTION_KEYS, 'ArrowLeft'],
+}
+export const SUB_CLOSE_KEYS: Record<MenuDirection, string[]> = {
+  ltr: ['ArrowLeft'],
+  rtl: ['ArrowRight'],
+}
+
+export function getOpenState(open: boolean) {
+  return open ? 'open' : 'closed'
+}
+
+export function isIndeterminate(checked?: CheckedState): checked is 'indeterminate' {
+  return checked === 'indeterminate'
+}
+
+export function getCheckedState(checked: CheckedState) {
+  return isIndeterminate(checked) ? 'indeterminate' : checked ? 'checked' : 'unchecked'
+}
+
+export function isPointerInGraceArea(event: { clientX: number; clientY: number }, area?: Polygon) {
+  if (!area) return false
+  return isPointInPolygon({ x: event.clientX, y: event.clientY }, area)
+}
+
+export function isMouseEvent(event: { pointerType: string }) {
+  return event.pointerType === 'mouse'
+}
+
+export function submenuGraceIntent(
+  event: { clientX: number; clientY: number },
+  contentRect: { left: number; right: number; top: number; bottom: number },
+  side: GraceSide,
+): GraceIntent {
+  const rightSide = side === 'right'
+  const bleed = rightSide ? -5 : +5
+  const contentNearEdge = contentRect[rightSide ? 'left' : 'right']
+  const contentFarEdge = contentRect[rightSide ? 'right' : 'left']
+  return {
+    area: [
+      { x: event.clientX + bleed, y: event.clientY },
+      { x: contentNearEdge, y: contentRect.top },
+      { x: contentFarEdge, y: contentRect.top },
+      { x: contentFarEdge, y: contentRect.bottom },
+      { x: contentNearEdge, y: contentRect.bottom },
+    ],
+    side,
+  }
+}

package/dist/shared/primitives/navigation-menu/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/navigation-menu/index.ts

@@ -0,0 +1,125 @@
+import { getActiveElement } from '../focus-scope'
+
+export type NavigationMenuAlign = 'start' | 'center' | 'end'
+
+export function getOpenState(open: boolean) {
+  return open ? 'open' : 'closed'
+}
+
+export function makeTriggerId(baseId: string, value: string) {
+  return `${baseId}-trigger-${value}`
+}
+
+export function makeContentId(baseId: string, value: string) {
+  return `${baseId}-content-${value}`
+}
+
+export const LINK_SELECT = 'navigationMenu.linkSelect'
+export const EVENT_ROOT_CONTENT_DISMISS = 'navigationMenu.rootContentDismiss'
+
+export function getTabbableCandidates(container: HTMLElement) {
+  const nodes: HTMLElement[] = []
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: node => {
+      const element = node as HTMLElement & { disabled?: boolean; type?: string }
+      const isHiddenInput = element.tagName === 'INPUT' && element.type === 'hidden'
+      if (element.disabled || element.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP
+      return element.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP
+    },
+  })
+  while (walker.nextNode()) nodes.push(walker.currentNode as HTMLElement)
+  return nodes
+}
+
+export function focusFirst(candidates: HTMLElement[]) {
+  const previouslyFocusedElement = getActiveElement()
+  return candidates.some(candidate => {
+    if (candidate === previouslyFocusedElement) return true
+    candidate.focus()
+    return getActiveElement() !== previouslyFocusedElement
+  })
+}
+
+export function removeFromTabOrder(candidates: HTMLElement[]) {
+  candidates.forEach(candidate => {
+    candidate.dataset.tabindex = candidate.getAttribute('tabindex') || ''
+    candidate.setAttribute('tabindex', '-1')
+  })
+  return () => {
+    candidates.forEach(candidate => {
+      const prevTabIndex = candidate.dataset.tabindex
+      candidate.setAttribute('tabindex', prevTabIndex!)
+    })
+  }
+}
+
+export function whenMouse<E extends PointerEvent>(handler: (event: E) => void) {
+  return (event: E) => (event.pointerType === 'mouse' ? handler(event) : undefined)
+}
+
+export interface MotionState {
+  triggers: HTMLElement[]
+  dir: 'ltr' | 'rtl'
+  modelValue: string
+  previousValue: string
+  value: string
+}
+
+export function getMotionAttribute(state: MotionState) {
+  const values = state.triggers.map(node => node.id.split('trigger-')[1])
+  if (state.dir === 'rtl') values.reverse()
+  const index = values.indexOf(state.modelValue)
+  const prevIndex = values.indexOf(state.previousValue)
+  const isSelected = state.value === state.modelValue
+  const wasSelected = prevIndex === values.indexOf(state.value)
+  if (!isSelected && !wasSelected) return undefined
+  if (index !== prevIndex) {
+    if (isSelected && prevIndex !== -1) return index > prevIndex ? 'from-end' : 'from-start'
+    if (wasSelected && index !== -1) return index > prevIndex ? 'to-start' : 'to-end'
+  }
+  return null
+}
+
+export function getViewportPosition(
+  root: HTMLElement,
+  trigger: HTMLElement,
+  content: HTMLElement,
+  align: NavigationMenuAlign | string | undefined,
+) {
+  const bodyWidth = document.documentElement.offsetWidth
+  const bodyHeight = document.documentElement.offsetHeight
+  const rootRect = root.getBoundingClientRect()
+  const rect = trigger.getBoundingClientRect()
+  const { offsetWidth, offsetHeight } = content
+  const startPositionLeft = rect.left - rootRect.left
+  const startPositionTop = rect.top - rootRect.top
+  let posLeft: number
+  let posTop: number
+  switch (align) {
+    case 'start':
+      posLeft = startPositionLeft
+      posTop = startPositionTop
+      break
+    case 'end':
+      posLeft = startPositionLeft - offsetWidth + rect.width
+      posTop = startPositionTop - offsetHeight + rect.height
+      break
+    default:
+      posLeft = startPositionLeft - offsetWidth / 2 + rect.width / 2
+      posTop = startPositionTop - offsetHeight / 2 + rect.height / 2
+  }
+  const screenOffset = 10
+  if (posLeft + rootRect.left < screenOffset) posLeft = screenOffset - rootRect.left
+  const rightOffset = posLeft + rootRect.left + offsetWidth
+  if (rightOffset > bodyWidth - screenOffset) {
+    posLeft -= rightOffset - bodyWidth + screenOffset
+    if (posLeft < screenOffset - rootRect.left) posLeft = screenOffset - rootRect.left
+  }
+  if (posTop + rootRect.top < screenOffset) posTop = screenOffset - rootRect.top
+  const bottomOffset = posTop + rootRect.top + offsetHeight
+  if (bottomOffset > bodyHeight - screenOffset) {
+    posTop -= bottomOffset - bodyHeight + screenOffset
+    if (posTop < screenOffset - rootRect.top) posTop = screenOffset - rootRect.top
+  }
+  return { left: Math.round(posLeft), top: Math.round(posTop) }
+}

package/dist/shared/primitives/popper/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/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.