@hina-ui/vue 1.7.6 → 1.7.7

package/dist/shared/primitives/dismissable-layer/index.ts

@@ -0,0 +1,203 @@
+export type PointerDownOutsideEvent = CustomEvent<{ originalEvent: PointerEvent }>
+export type FocusOutsideEvent = CustomEvent<{ originalEvent: FocusEvent }>
+
+export const POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside'
+export const FOCUS_OUTSIDE = 'dismissableLayer.focusOutside'
+
+const layers = new Set<HTMLElement>()
+const blocking = new Set<HTMLElement>()
+const branches = new Set<HTMLElement>()
+const listeners = new Set<() => void>()
+let originalBodyPointerEvents: string | undefined
+let version = 0
+
+function changed() {
+  version += 1
+  for (const listener of listeners) listener()
+}
+
+export function subscribeLayers(listener: () => void) {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+export function layersVersion() {
+  return version
+}
+
+export function addLayer(element: HTMLElement) {
+  layers.add(element)
+  changed()
+  return () => {
+    if (layers.delete(element)) changed()
+  }
+}
+
+export function addBranch(element: HTMLElement) {
+  branches.add(element)
+  changed()
+  return () => {
+    if (branches.delete(element)) changed()
+  }
+}
+
+export function blockOutsidePointerEvents(element: HTMLElement) {
+  const body = element.ownerDocument.body
+  if (blocking.size === 0) {
+    originalBodyPointerEvents = body.style.pointerEvents
+    body.style.pointerEvents = 'none'
+  }
+  blocking.add(element)
+  changed()
+  return () => {
+    if (!blocking.delete(element)) return
+    if (blocking.size === 0 && originalBodyPointerEvents != null)
+      body.style.pointerEvents = originalBodyPointerEvents
+    changed()
+  }
+}
+
+export function releaseLayer(element: HTMLElement) {
+  const removed = layers.delete(element)
+  const unblocked = blocking.delete(element)
+  if (removed || unblocked) changed()
+}
+
+export function blockingLayerCount() {
+  return blocking.size
+}
+
+export function layerIndex(element: HTMLElement | null | undefined) {
+  return element ? [...layers].indexOf(element) : -1
+}
+
+export function isHighestLayer(element: HTMLElement | null | undefined) {
+  return layerIndex(element) === layers.size - 1
+}
+
+export function bodyPointerEventsDisabled() {
+  return blocking.size > 0
+}
+
+export function pointerEventsEnabled(element: HTMLElement | null | undefined) {
+  const highest = [...blocking].at(-1)
+  return layerIndex(element) >= (highest ? [...layers].indexOf(highest) : -1)
+}
+
+export function layerPointerEvents(element: HTMLElement | null | undefined) {
+  if (!bodyPointerEventsDisabled()) return undefined
+  return pointerEventsEnabled(element) ? 'auto' : 'none'
+}
+
+export function inBranch(target: EventTarget | null) {
+  return [...branches].some(branch => branch.contains(target as Node | null))
+}
+
+export function isLayerExist(layer: HTMLElement, target: EventTarget | null) {
+  if (!(target instanceof Element)) return false
+  const targetLayer = target.closest('[data-dismissable-layer]')
+  const mainLayer =
+    layer.dataset.dismissableLayer === ''
+      ? layer
+      : layer.querySelector<HTMLElement>('[data-dismissable-layer]')
+  const all = Array.from(layer.ownerDocument.querySelectorAll('[data-dismissable-layer]'))
+  return (
+    !!targetLayer &&
+    !!mainLayer &&
+    (mainLayer === targetLayer || all.indexOf(mainLayer) < all.indexOf(targetLayer))
+  )
+}
+
+export function handleAndDispatchCustomEvent<E extends CustomEvent<{ originalEvent: Event }>>(
+  name: string,
+  handler: ((event: E) => void) | undefined,
+  detail: E['detail'],
+) {
+  const target = detail.originalEvent.target as EventTarget
+  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail })
+  if (handler) target.addEventListener(name, handler as EventListener, { once: true })
+  target.dispatchEvent(event)
+}
+
+export interface OutsideWatcher<E> {
+  element: () => HTMLElement | null | undefined
+  onOutside: (event: E) => void
+}
+
+export function watchPointerDownOutside({
+  element,
+  onOutside,
+}: OutsideWatcher<PointerDownOutsideEvent>) {
+  const ownerDocument = element()?.ownerDocument ?? globalThis.document
+  let inside = false
+  let pendingClick: () => void = () => {}
+
+  const handlePointerDown = (event: PointerEvent) => {
+    const layer = element()
+    const target = event.target as HTMLElement | null
+    if (!layer || !target) return
+    if (isLayerExist(layer, target)) {
+      inside = false
+      return
+    }
+    if (!inside) {
+      const dispatch = () =>
+        handleAndDispatchCustomEvent(POINTER_DOWN_OUTSIDE, onOutside, { originalEvent: event })
+      if (event.pointerType === 'touch') {
+        ownerDocument.removeEventListener('click', pendingClick)
+        pendingClick = dispatch
+        ownerDocument.addEventListener('click', pendingClick, { once: true })
+      } else dispatch()
+    } else ownerDocument.removeEventListener('click', pendingClick)
+    inside = false
+  }
+
+  const timer = window.setTimeout(() => {
+    ownerDocument.addEventListener('pointerdown', handlePointerDown)
+  }, 0)
+
+  return {
+    onPointerDownCapture() {
+      inside = true
+    },
+    stop() {
+      window.clearTimeout(timer)
+      ownerDocument.removeEventListener('pointerdown', handlePointerDown)
+      ownerDocument.removeEventListener('click', pendingClick)
+    },
+  }
+}
+
+export function watchFocusOutside({
+  element,
+  onOutside,
+  settle,
+}: OutsideWatcher<FocusOutsideEvent> & { settle?: () => Promise<void> }) {
+  const ownerDocument = element()?.ownerDocument ?? globalThis.document
+  let inside = false
+
+  const handleFocus = async (event: FocusEvent) => {
+    if (!element()) return
+    if (settle) await settle()
+    const layer = element()
+    const target = event.target as HTMLElement | null
+    if (!layer || !target || isLayerExist(layer, target)) return
+    if (!inside) handleAndDispatchCustomEvent(FOCUS_OUTSIDE, onOutside, { originalEvent: event })
+  }
+
+  ownerDocument.addEventListener('focusin', handleFocus)
+
+  return {
+    onFocusCapture() {
+      inside = true
+    },
+    onBlurCapture() {
+      inside = false
+    },
+    stop() {
+      ownerDocument.removeEventListener('focusin', handleFocus)
+    },
+  }
+}

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

@@ -0,0 +1,24 @@
+const GUARD = 'data-reka-focus-guard'
+let count = 0
+
+function createFocusGuard() {
+  const element = document.createElement('span')
+  element.setAttribute(GUARD, '')
+  element.tabIndex = 0
+  element.style.outline = 'none'
+  element.style.opacity = '0'
+  element.style.position = 'fixed'
+  element.style.pointerEvents = 'none'
+  return element
+}
+
+export function installFocusGuards() {
+  const edges = document.querySelectorAll(`[${GUARD}]`)
+  document.body.insertAdjacentElement('afterbegin', edges[0] ?? createFocusGuard())
+  document.body.insertAdjacentElement('beforeend', edges[1] ?? createFocusGuard())
+  count += 1
+  return () => {
+    if (count === 1) for (const node of document.querySelectorAll(`[${GUARD}]`)) node.remove()
+    count -= 1
+  }
+}

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

@@ -0,0 +1,216 @@
+export const AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount'
+export const AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount'
+const EVENT_OPTIONS = { bubbles: false, cancelable: true }
+
+type FocusableTarget = HTMLElement | { focus: (options?: FocusOptions) => void }
+
+export interface FocusScopeAPI {
+  paused: boolean
+  pause: () => void
+  resume: () => void
+}
+
+export function createFocusScopeAPI(onChange?: () => void): FocusScopeAPI {
+  return {
+    paused: false,
+    pause() {
+      this.paused = true
+      onChange?.()
+    },
+    resume() {
+      this.paused = false
+      onChange?.()
+    },
+  }
+}
+
+let stack: FocusScopeAPI[] = []
+
+function without<T>(array: T[], item: T) {
+  return array.filter(entry => entry !== item)
+}
+
+export const focusScopesStack = {
+  add(scope: FocusScopeAPI) {
+    const active = stack[0]
+    if (scope !== active) active?.pause()
+    stack = without(stack, scope)
+    stack.unshift(scope)
+  },
+  remove(scope: FocusScopeAPI) {
+    stack = without(stack, scope)
+    stack[0]?.resume()
+  },
+}
+
+export function getActiveElement(): Element | null {
+  let active = document.activeElement
+  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement
+  return active ?? null
+}
+
+export function isSelectableInput(
+  element: unknown,
+): element is HTMLInputElement & { select: () => void } {
+  return element instanceof HTMLInputElement && 'select' in element
+}
+
+export function focus(element?: FocusableTarget | null, { select = false } = {}) {
+  if (!element?.focus) return
+  const previous = getActiveElement()
+  element.focus({ preventScroll: true })
+  if (element !== previous && isSelectableInput(element) && select) element.select()
+}
+
+export function focusFirst(candidates: HTMLElement[], { select = false } = {}) {
+  const previous = getActiveElement()
+  for (const candidate of candidates) {
+    focus(candidate, { select })
+    if (getActiveElement() !== previous) return true
+  }
+}
+
+export function getTabbableCandidates(container: HTMLElement) {
+  const nodes: HTMLElement[] = []
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: node => {
+      const element = node as HTMLInputElement
+      const hiddenInput = element.tagName === 'INPUT' && element.type === 'hidden'
+      if (element.disabled || element.hidden || hiddenInput) 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 isHidden(node: HTMLElement, { upTo }: { upTo?: HTMLElement }) {
+  if (getComputedStyle(node).visibility === 'hidden') return true
+  let current: HTMLElement | null = node
+  while (current) {
+    if (upTo !== undefined && current === upTo) return false
+    if (getComputedStyle(current).display === 'none') return true
+    current = current.parentElement
+  }
+  return false
+}
+
+export function findVisible(elements: HTMLElement[], container: HTMLElement) {
+  return elements.find(element => !isHidden(element, { upTo: container }))
+}
+
+export function getTabbableEdges(container: HTMLElement) {
+  const candidates = getTabbableCandidates(container)
+  return [
+    findVisible(candidates, container),
+    findVisible([...candidates].reverse(), container),
+  ] as const
+}
+
+export function removeLinks(items: HTMLElement[]) {
+  return items.filter(item => item.tagName !== 'A')
+}
+
+export function trapFocus(container: HTMLElement, scope: FocusScopeAPI) {
+  let lastFocused: HTMLElement | null = null
+
+  const handleFocusIn = (event: FocusEvent) => {
+    if (scope.paused) return
+    const target = event.target as HTMLElement | null
+    if (container.contains(target)) lastFocused = target
+    else focus(lastFocused, { select: true })
+  }
+
+  const handleFocusOut = (event: FocusEvent) => {
+    if (scope.paused) return
+    const related = event.relatedTarget as HTMLElement | null
+    if (related === null) return
+    if (!container.contains(related)) focus(lastFocused, { select: true })
+  }
+
+  const handleMutations = (mutations: MutationRecord[]) => {
+    if (lastFocused === null) return
+    if (!mutations.some(mutation => mutation.removedNodes.length > 0)) return
+    const active = getActiveElement()
+    if (active && container.contains(active)) return
+    if (!container.contains(lastFocused)) focus(container)
+  }
+
+  document.addEventListener('focusin', handleFocusIn)
+  document.addEventListener('focusout', handleFocusOut)
+  const observer = new MutationObserver(handleMutations)
+  observer.observe(container, { childList: true, subtree: true })
+
+  return () => {
+    document.removeEventListener('focusin', handleFocusIn)
+    document.removeEventListener('focusout', handleFocusOut)
+    observer.disconnect()
+  }
+}
+
+export function dispatchMountAutoFocus(
+  container: HTMLElement,
+  previous: Element | null,
+  onMountAutoFocus?: (event: Event) => void,
+) {
+  const event = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS)
+  const handler = (mountEvent: Event) => onMountAutoFocus?.(mountEvent)
+  container.addEventListener(AUTOFOCUS_ON_MOUNT, handler)
+  container.dispatchEvent(event)
+  container.removeEventListener(AUTOFOCUS_ON_MOUNT, handler)
+  if (!event.defaultPrevented) {
+    focusFirst(getTabbableCandidates(container), { select: true })
+    if (getActiveElement() === previous) focus(container)
+  }
+}
+
+export function dispatchUnmountAutoFocus(
+  container: HTMLElement,
+  previous: Element | null,
+  scope: FocusScopeAPI,
+  onUnmountAutoFocus?: (event: Event) => void,
+) {
+  const event = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS)
+  const handler = (unmountEvent: Event) => onUnmountAutoFocus?.(unmountEvent)
+  container.addEventListener(AUTOFOCUS_ON_UNMOUNT, handler)
+  container.dispatchEvent(event)
+  container.setAttribute('data-focus-scope-unmounting', '')
+  setTimeout(() => {
+    if (!event.defaultPrevented)
+      focus((previous as HTMLElement | null) ?? document.body, { select: true })
+    container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, handler)
+    focusScopesStack.remove(scope)
+    container.removeAttribute('data-focus-scope-unmounting')
+  }, 0)
+}
+
+export interface FocusScopeKeyEvent {
+  key: string
+  altKey: boolean
+  ctrlKey: boolean
+  metaKey: boolean
+  shiftKey: boolean
+  currentTarget: EventTarget | null
+  preventDefault: () => void
+}
+
+export function handleFocusScopeKeyDown(
+  event: FocusScopeKeyEvent,
+  { loop, trapped, scope }: { loop: boolean; trapped: boolean; scope: FocusScopeAPI },
+) {
+  if ((!loop && !trapped) || scope.paused) return
+  const tab = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey
+  const focused = getActiveElement()
+  if (!tab || !focused) return
+  const container = event.currentTarget as HTMLElement
+  const [first, last] = getTabbableEdges(container)
+  if (!first || !last) {
+    if (focused === container) event.preventDefault()
+  } else if (!event.shiftKey && focused === last) {
+    event.preventDefault()
+    if (loop) focus(first, { select: true })
+  } else if (event.shiftKey && focused === first) {
+    event.preventDefault()
+    if (loop) focus(last, { select: true })
+  }
+}

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

@@ -0,0 +1,4 @@
+export function getLabelText(id: string | undefined, element: Element | null | undefined) {
+  if (!id || !element) return undefined
+  return element.ownerDocument.querySelector<HTMLElement>(`[for="${id}"]`)?.innerText
+}

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

@@ -0,0 +1,99 @@
+export type PaginationItems = Array<{ type: 'ellipsis' } | { type: 'page'; value: number }>
+
+function range(start: number, end: number) {
+  const length = end - start + 1
+  return Array.from({ length }, (_, idx) => idx + start)
+}
+
+export function transform(items: (string | number)[]): PaginationItems {
+  return items.map(value => {
+    if (typeof value === 'number') return { type: 'page', value }
+    return { type: 'ellipsis' }
+  })
+}
+
+const ELLIPSIS = 'ellipsis'
+
+export function getRange(
+  currentPage: number,
+  pageCount: number,
+  siblingCount: number,
+  showEdges: boolean,
+) {
+  const firstPageIndex = 1
+  const lastPageIndex = pageCount
+
+  const leftSiblingIndex = Math.max(currentPage - siblingCount, firstPageIndex)
+  const rightSiblingIndex = Math.min(currentPage + siblingCount, lastPageIndex)
+
+  if (showEdges) {
+    const totalPageNumbers = Math.min(2 * siblingCount + 5, pageCount)
+
+    const itemCount = totalPageNumbers - 2
+
+    const showLeftEllipsis =
+      leftSiblingIndex > firstPageIndex + 2 &&
+      Math.abs(lastPageIndex - itemCount - firstPageIndex + 1) > 2 &&
+      Math.abs(leftSiblingIndex - firstPageIndex) > 2
+
+    const showRightEllipsis =
+      rightSiblingIndex < lastPageIndex - 2 &&
+      Math.abs(lastPageIndex - itemCount) > 2 &&
+      Math.abs(lastPageIndex - rightSiblingIndex) > 2
+
+    if (!showLeftEllipsis && showRightEllipsis) {
+      const leftRange = range(1, itemCount)
+
+      return [...leftRange, ELLIPSIS, lastPageIndex]
+    }
+
+    if (showLeftEllipsis && !showRightEllipsis) {
+      const rightRange = range(lastPageIndex - itemCount + 1, lastPageIndex)
+
+      return [firstPageIndex, ELLIPSIS, ...rightRange]
+    }
+
+    if (showLeftEllipsis && showRightEllipsis) {
+      const middleRange = range(leftSiblingIndex, rightSiblingIndex)
+
+      return [firstPageIndex, ELLIPSIS, ...middleRange, ELLIPSIS, lastPageIndex]
+    }
+
+    const fullRange = range(firstPageIndex, lastPageIndex)
+    return fullRange
+  } else {
+    const itemCount = siblingCount * 2 + 1
+
+    if (pageCount < itemCount) return range(1, lastPageIndex)
+    else if (currentPage <= siblingCount + 1) return range(firstPageIndex, itemCount)
+    else if (pageCount - currentPage <= siblingCount)
+      return range(pageCount - itemCount + 1, lastPageIndex)
+    else return range(leftSiblingIndex, rightSiblingIndex)
+  }
+}
+
+export type PaginationEdge = 'first' | 'prev' | 'next' | 'last'
+
+export function paginationPageCount(total: number, itemsPerPage: number) {
+  return Math.max(1, Math.ceil(total / (itemsPerPage || 1)))
+}
+
+export function paginationEdgeDisabled(
+  edge: PaginationEdge,
+  page: number,
+  pageCount: number,
+  disabled: boolean,
+) {
+  return (edge === 'first' || edge === 'prev' ? page === 1 : page === pageCount) || disabled
+}
+
+export function paginationEdgeTarget(edge: PaginationEdge, page: number, pageCount: number) {
+  return edge === 'first' ? 1 : edge === 'prev' ? page - 1 : edge === 'next' ? page + 1 : pageCount
+}
+
+export const PAGINATION_EDGES: Record<PaginationEdge, { label: string; fallback: string }> = {
+  first: { label: 'First Page', fallback: 'First page' },
+  prev: { label: 'Previous Page', fallback: 'Prev page' },
+  next: { label: 'Next Page', fallback: 'Next page' },
+  last: { label: 'Last Page', fallback: 'Last page' },
+}

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