@hina-ui/vue 1.7.6 → 1.7.8

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.

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

@@ -0,0 +1,126 @@
+import { arrowNavigation } from '../arrow-navigation'
+
+export type PinInputValue = Array<string | number | undefined>
+
+const NUMBER = /^\d*$/
+const NON_NUMBER = /\D/g
+const NAVIGATION_KEYS = ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown', 'Home', 'End']
+
+export function pinInputValues(value: unknown): PinInputValue {
+  return Array.isArray(value) ? [...value] : []
+}
+
+export function isPinInputComplete(values: PinInputValue, count: number, numeric: boolean) {
+  return values.filter(value => !!value || (numeric && value === 0)).length === count
+}
+
+export function stripPinNonNumbers(value: string) {
+  return value.replace(NON_NUMBER, '')
+}
+
+function removeTrailingEmptyStrings(values: PinInputValue) {
+  while (values.length && values[values.length - 1] === '') values.pop()
+  return values
+}
+
+export function setPinValueAt(
+  current: PinInputValue,
+  index: number,
+  value: string,
+  numeric: boolean,
+) {
+  const values = [...current]
+  if (numeric) {
+    const number = +value
+    if (value === '' || Number.isNaN(number)) delete values[index]
+    else values[index] = number
+  } else values[index] = value
+  return removeTrailingEmptyStrings(values)
+}
+
+export function spreadPinValue(
+  current: PinInputValue,
+  characters: string,
+  index: number,
+  count: number,
+  numeric: boolean,
+) {
+  const values = [...current]
+  const start = characters.length >= count ? 0 : index
+  const end = Math.min(start + characters.length, count)
+  const filled: number[] = []
+  for (let at = start; at < end; at++) {
+    const character = characters[at - start]!
+    if (numeric) {
+      const number = Number.parseInt(character)
+      if (Number.isNaN(number)) continue
+      values[at] = number
+    } else values[at] = character
+    filled.push(at)
+  }
+  return { values, filled, end }
+}
+
+export type PinTextAction =
+  | { kind: 'clear' }
+  | { kind: 'filter'; value: string }
+  | { kind: 'spread'; characters: string }
+  | { kind: 'single'; character: string }
+
+export function resolvePinComposition(value: string, numeric: boolean): PinTextAction {
+  const text = numeric ? stripPinNonNumbers(value) : value
+  if (numeric && !text) return { kind: 'clear' }
+  if (text.length > 1) return { kind: 'spread', characters: text }
+  return { kind: 'single', character: text }
+}
+
+export function resolvePinInput(
+  data: string | null | undefined,
+  value: string,
+  numeric: boolean,
+): PinTextAction {
+  if ((data?.length ?? 0) > 1) return { kind: 'spread', characters: value }
+  if (numeric && !NUMBER.test(value)) return { kind: 'filter', value: stripPinNonNumbers(value) }
+  return { kind: 'single', character: data || value.slice(-1) }
+}
+
+export function resolvePinPaste(text: string, numeric: boolean) {
+  return numeric ? stripPinNonNumbers(text) : text
+}
+
+export function pinFocusRedirect(values: PinInputValue, count: number, index: number) {
+  for (let at = 0; at < count; at++)
+    if (values[at] === '' || values[at] === undefined) return at < index ? at : -1
+  return -1
+}
+
+export function isPinNavigationKey(key: string) {
+  return NAVIGATION_KEYS.includes(key)
+}
+
+export function navigatePin(
+  event: KeyboardEvent,
+  current: HTMLElement | null,
+  inputs: HTMLElement[],
+  dir: 'ltr' | 'rtl',
+) {
+  arrowNavigation(event, current, undefined, {
+    itemsArray: inputs,
+    focus: true,
+    loop: false,
+    arrowKeyOptions: 'horizontal',
+    dir,
+  })
+}
+
+export function pinPlaceholder(
+  element: HTMLInputElement,
+  active: Element | null,
+  placeholder: string,
+) {
+  element.placeholder = !element.value && element === active ? '' : placeholder
+}
+
+export function pinInputLabel(index: number, count: number) {
+  return `pin input ${index + 1} of ${count}`
+}

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

@@ -0,0 +1,135 @@
+export type PresenceState = 'mounted' | 'unmountSuspended' | 'unmounted'
+type PresenceEvent = 'MOUNT' | 'UNMOUNT' | 'ANIMATION_OUT' | 'ANIMATION_END'
+type PresenceTransition = 'enter' | 'after-enter' | 'leave' | 'after-leave'
+
+const MACHINE: Record<PresenceState, Partial<Record<PresenceEvent, PresenceState>>> = {
+  mounted: { UNMOUNT: 'unmounted', ANIMATION_OUT: 'unmountSuspended' },
+  unmountSuspended: { MOUNT: 'mounted', ANIMATION_END: 'unmounted' },
+  unmounted: { MOUNT: 'mounted' },
+}
+
+export function getAnimationName(node?: HTMLElement | null) {
+  return node ? getComputedStyle(node).animationName || 'none' : 'none'
+}
+
+export interface PresenceController {
+  readonly state: PresenceState
+  readonly present: boolean
+  setNode: (node: HTMLElement | null | undefined) => void
+  update: (present: boolean, previous: boolean | undefined) => void
+  dispose: () => void
+}
+
+export interface PresenceOptions {
+  fillForwards?: boolean
+}
+
+export function createPresence(
+  initial: boolean,
+  onStateChange: (state: PresenceState) => void,
+  { fillForwards = true }: PresenceOptions = {},
+): PresenceController {
+  let state: PresenceState = initial ? 'mounted' : 'unmounted'
+  let present = initial
+  let node: HTMLElement | null | undefined
+  let styles: CSSStyleDeclaration | undefined
+  let previousAnimationName = 'none'
+  let timeout: number | undefined
+
+  const ownerWindow = () => node?.ownerDocument.defaultView ?? globalThis.window
+
+  function send(event: PresenceEvent) {
+    const next = MACHINE[state][event]
+    if (!next || next === state) return
+    state = next
+    previousAnimationName = state === 'mounted' ? getAnimationName(node) : 'none'
+    onStateChange(state)
+  }
+
+  function emit(name: PresenceTransition) {
+    node?.dispatchEvent(new CustomEvent(name, { bubbles: false, cancelable: false }))
+  }
+
+  function handleAnimationStart(event: AnimationEvent) {
+    if (event.target === node) previousAnimationName = getAnimationName(node)
+  }
+
+  function handleAnimationEnd(event: AnimationEvent) {
+    if (!node || event.target !== node) return
+    const current = getAnimationName(node)
+    if (current.includes(CSS.escape(event.animationName))) {
+      emit(state === 'mounted' ? 'after-enter' : 'after-leave')
+      send('ANIMATION_END')
+      if (fillForwards && !present) {
+        const element = node
+        const fillMode = element.style.animationFillMode
+        element.style.animationFillMode = 'forwards'
+        timeout = ownerWindow()?.setTimeout(() => {
+          if (element.style.animationFillMode === 'forwards')
+            element.style.animationFillMode = fillMode
+        })
+      }
+    }
+    if (current === 'none') send('ANIMATION_END')
+  }
+
+  function detach(element: HTMLElement) {
+    element.removeEventListener('animationstart', handleAnimationStart)
+    element.removeEventListener('animationcancel', handleAnimationEnd)
+    element.removeEventListener('animationend', handleAnimationEnd)
+  }
+
+  return {
+    get state() {
+      return state
+    },
+    get present() {
+      return state === 'mounted' || state === 'unmountSuspended'
+    },
+    setNode(next) {
+      if (next === node) return
+      const previous = node
+      node = next
+      if (next) {
+        styles = getComputedStyle(next)
+        next.addEventListener('animationstart', handleAnimationStart)
+        next.addEventListener('animationcancel', handleAnimationEnd)
+        next.addEventListener('animationend', handleAnimationEnd)
+      } else {
+        send('ANIMATION_END')
+        if (timeout !== undefined) ownerWindow()?.clearTimeout(timeout)
+      }
+      if (previous) detach(previous)
+    },
+    update(current, previous) {
+      present = current
+      if (previous === current) return
+      const previousName = previousAnimationName
+      const currentName = getAnimationName(node)
+      if (current) {
+        send('MOUNT')
+        emit('enter')
+        if (currentName === 'none') emit('after-enter')
+      } else if (
+        currentName === 'none' ||
+        currentName === 'undefined' ||
+        styles?.display === 'none'
+      ) {
+        send('UNMOUNT')
+        emit('leave')
+        emit('after-leave')
+      } else if (previous && previousName !== currentName) {
+        send('ANIMATION_OUT')
+        emit('leave')
+      } else {
+        send('UNMOUNT')
+        emit('after-leave')
+      }
+    },
+    dispose() {
+      if (node) detach(node)
+      if (timeout !== undefined) ownerWindow()?.clearTimeout(timeout)
+      node = undefined
+    },
+  }
+}

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