@hina-ui/vue 1.7.6 → 1.7.8

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

@@ -0,0 +1,41 @@
+export const DEFAULT_PROGRESS_MAX = 100
+
+export type ProgressState = 'indeterminate' | 'complete' | 'loading'
+
+export function isNumber(value: unknown): value is number {
+  return typeof value === 'number'
+}
+
+export function isValidProgressMax(max: unknown): max is number {
+  return isNumber(max) && !Number.isNaN(max) && max > 0
+}
+
+export function isValidProgressValue(
+  value: unknown,
+  max: number,
+): value is number | null | undefined {
+  return value == null || (isNumber(value) && !Number.isNaN(value) && value <= max && value >= 0)
+}
+
+export function progressValueError(value: unknown) {
+  return `Invalid prop \`value\` of value \`${value}\` supplied to \`ProgressRoot\`. The \`value\` prop must be:
+  - a positive number
+  - less than the value passed to \`max\` (or ${DEFAULT_PROGRESS_MAX} if no \`max\` prop is set)
+  - \`null\`  or \`undefined\` if the progress is indeterminate.
+
+Defaulting to \`null\`.`
+}
+
+export function progressMaxError(max: unknown) {
+  return `Invalid prop \`max\` of value \`${max}\` supplied to \`ProgressRoot\`. Only numbers greater than 0 are valid max values. Defaulting to \`${DEFAULT_PROGRESS_MAX}\`.`
+}
+
+export function progressState(value: number | null | undefined, max: number): ProgressState {
+  if (value == null) return 'indeterminate'
+  if (value === max) return 'complete'
+  return 'loading'
+}
+
+export function defaultProgressLabel(value: number | null | undefined, max: number) {
+  return isNumber(value) ? `${Math.round((value / max) * DEFAULT_PROGRESS_MAX)}%` : undefined
+}

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

@@ -0,0 +1,46 @@
+import { handleAndDispatchCustomEvent } from '../dismissable-layer'
+
+export const RADIO_SELECT = 'radio.select'
+
+const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight']
+
+export interface RadioSelectDetail<T = unknown, E extends Event = Event> {
+  originalEvent: E
+  value: T
+}
+
+export type RadioSelectEvent<T = unknown, E extends Event = Event> = CustomEvent<
+  RadioSelectDetail<T, E>
+>
+
+export function dispatchRadioSelect<T, E extends Event>(
+  event: E,
+  value: T,
+  callback: (event: RadioSelectEvent<T, E>) => void,
+) {
+  handleAndDispatchCustomEvent<RadioSelectEvent<T, E>>(RADIO_SELECT, callback, {
+    originalEvent: event,
+    value,
+  })
+}
+
+export function trackArrowKeys(target: Window) {
+  let pressed = false
+  const down = (event: KeyboardEvent) => {
+    if (ARROW_KEYS.includes(event.key)) pressed = true
+  }
+  const up = () => {
+    pressed = false
+  }
+  target.addEventListener('keydown', down)
+  target.addEventListener('keyup', up)
+  return {
+    get pressed() {
+      return pressed
+    },
+    dispose() {
+      target.removeEventListener('keydown', down)
+      target.removeEventListener('keyup', up)
+    },
+  }
+}

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

@@ -0,0 +1,37 @@
+export function ratingItems(length: number) {
+  return Array.from({ length }, (_, index) => index + 1)
+}
+
+export function ratingSteps(item: number, stepSize: number) {
+  const start = item - 1
+  const count = Math.ceil((item - start) / stepSize)
+  return Array.from({ length: count }, (_, index) =>
+    Number((start + (index + 1) * stepSize).toFixed(2)),
+  )
+}
+
+export function nextRating(clearable: boolean, current: number | undefined, rating: number) {
+  return clearable && current === rating ? 0 : rating
+}
+
+export function isRatingStepActive(step: number, hovered: number, value: number | undefined) {
+  return (hovered > 0 && step <= hovered) || (hovered === 0 && step <= (value ?? Number.NaN))
+}
+
+export function isRatingStepVisible(
+  focused: boolean,
+  stepSize: number,
+  step: number,
+  hovered: number,
+  value: number | undefined,
+) {
+  return focused || stepSize === 1 || step % 1 === 0 || step === hovered || step === value
+}
+
+export function ratingStepWidth(step: number) {
+  return `${(step % 1 || 1) * 100}%`
+}
+
+export function ratingStepZIndex(steps: number[], step: number) {
+  return steps.length - steps.indexOf(step)
+}

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

@@ -0,0 +1,44 @@
+import { getActiveElement } from '../focus-scope'
+
+export type Orientation = 'horizontal' | 'vertical'
+export type Direction = 'ltr' | 'rtl'
+export type FocusIntent = 'first' | 'last' | 'prev' | 'next'
+
+export const ENTRY_FOCUS = 'rovingFocusGroup.onEntryFocus'
+export const ENTRY_FOCUS_OPTIONS = { bubbles: false, cancelable: true }
+
+const KEY_TO_INTENT: Record<string, FocusIntent> = {
+  ArrowLeft: 'prev',
+  ArrowUp: 'prev',
+  ArrowRight: 'next',
+  ArrowDown: 'next',
+  PageUp: 'first',
+  Home: 'first',
+  PageDown: 'last',
+  End: 'last',
+}
+
+export function getDirectionAwareKey(key: string, dir?: Direction) {
+  if (dir !== 'rtl') return key
+  return key === 'ArrowLeft' ? 'ArrowRight' : key === 'ArrowRight' ? 'ArrowLeft' : key
+}
+
+export function getFocusIntent(event: KeyboardEvent, orientation?: Orientation, dir?: Direction) {
+  const key = getDirectionAwareKey(event.key, dir)
+  if (orientation === 'vertical' && (key === 'ArrowLeft' || key === 'ArrowRight')) return undefined
+  if (orientation === 'horizontal' && (key === 'ArrowUp' || key === 'ArrowDown')) return undefined
+  return KEY_TO_INTENT[key]
+}
+
+export function focusFirstCandidate(candidates: HTMLElement[], preventScroll = false) {
+  const previous = getActiveElement()
+  for (const candidate of candidates) {
+    if (candidate === previous) return
+    candidate.focus({ preventScroll })
+    if (getActiveElement() !== previous) return
+  }
+}
+
+export function wrapArray<T>(array: T[], startIndex: number) {
+  return array.map((_, index) => array[(startIndex + index) % array.length]!)
+}

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

@@ -0,0 +1,14 @@
+export type SeparatorOrientation = 'horizontal' | 'vertical'
+
+export function separatorOrientation(orientation: unknown): SeparatorOrientation {
+  return orientation === 'vertical' ? 'vertical' : 'horizontal'
+}
+
+export function separatorSemantics(orientation: SeparatorOrientation, decorative?: boolean) {
+  return decorative
+    ? { role: 'none' as const }
+    : {
+        'aria-orientation': orientation === 'vertical' ? orientation : undefined,
+        role: 'separator' as const,
+      }
+}

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

@@ -0,0 +1,19 @@
+export interface Size {
+  width: number
+  height: number
+}
+
+export function measureSize(element: HTMLElement): Size {
+  return { width: element.offsetWidth, height: element.offsetHeight }
+}
+
+export function observeSize(element: HTMLElement, onChange: (size: Size) => void) {
+  const observer = new ResizeObserver(entries => {
+    if (!Array.isArray(entries) || !entries.length) return
+    const entry = entries[0]!
+    const border = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize
+    onChange(border ? { width: border.inlineSize, height: border.blockSize } : measureSize(element))
+  })
+  observer.observe(element, { box: 'border-box' })
+  return () => observer.disconnect()
+}

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

@@ -0,0 +1,183 @@
+export function clamp(
+  value: number,
+  min = Number.NEGATIVE_INFINITY,
+  max = Number.POSITIVE_INFINITY,
+) {
+  return Math.min(max, Math.max(min, value))
+}
+
+export function getNextSortedValues(prevValues: number[] = [], nextValue: number, atIndex: number) {
+  const nextValues = [...prevValues]
+  nextValues[atIndex] = nextValue
+  return nextValues.sort((a, b) => a - b)
+}
+
+export function convertValueToPercentage(value: number, min: number, max: number) {
+  const maxSteps = max - min
+  const percentPerStep = 100 / maxSteps
+  const percentage = percentPerStep * (value - min)
+  return clamp(percentage, 0, 100)
+}
+
+export function getLabel(index: number, totalValues: number) {
+  if (totalValues > 2) return `Value ${index + 1} of ${totalValues}`
+  if (totalValues === 2) return ['Minimum', 'Maximum'][index]
+  return undefined
+}
+
+export function getClosestValueIndex(values: number[], nextValue: number) {
+  if (values.length === 1) return 0
+  const distances = values.map(value => Math.abs(value - nextValue))
+  const closestDistance = Math.min(...distances)
+  return distances.indexOf(closestDistance)
+}
+
+export function linearScale(input: readonly [number, number], output: readonly [number, number]) {
+  return (value: number) => {
+    if (input[0] === input[1] || output[0] === output[1]) return output[0]
+    const ratio = (output[1] - output[0]) / (input[1] - input[0])
+    return output[0] + ratio * (value - input[0])
+  }
+}
+
+export function getThumbInBoundsOffset(width: number, left: number, direction: number) {
+  const halfWidth = width / 2
+  const halfPercent = 50
+  const offset = linearScale([0, halfPercent], [0, halfWidth])
+  return (halfWidth - offset(left) * direction) * direction
+}
+
+function getStepsBetweenValues(values: number[]) {
+  return values.slice(0, -1).map((value, index) => values[index + 1]! - value)
+}
+
+export function hasMinStepsBetweenValues(values: number[], minStepsBetweenValues: number) {
+  if (minStepsBetweenValues > 0) {
+    const stepsBetweenValues = getStepsBetweenValues(values)
+    const actualMinStepsBetweenValues = Math.min(...stepsBetweenValues)
+    return actualMinStepsBetweenValues >= minStepsBetweenValues
+  }
+  return true
+}
+
+export function getDecimalCount(value: number) {
+  return (String(value).split('.')[1] || '').length
+}
+
+export function roundValue(value: number, decimalCount: number) {
+  const rounder = 10 ** decimalCount
+  return Math.round(value * rounder) / rounder
+}
+
+export const PAGE_KEYS = ['PageUp', 'PageDown']
+export const ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight']
+export const BACK_KEYS: Record<string, string[]> = {
+  'from-left': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],
+  'from-right': ['Home', 'PageDown', 'ArrowDown', 'ArrowRight'],
+  'from-bottom': ['Home', 'PageDown', 'ArrowDown', 'ArrowLeft'],
+  'from-top': ['Home', 'PageUp', 'ArrowUp', 'ArrowLeft'],
+}
+
+export function resolveSliderUpdate(
+  values: number[],
+  value: number,
+  atIndex: number,
+  options: { min: number; max: number; step: number; minStepsBetweenThumbs: number },
+) {
+  const { min, max, step, minStepsBetweenThumbs } = options
+  const snapped = roundValue(Math.round((value - min) / step) * step + min, getDecimalCount(step))
+  const nextValue = clamp(snapped, min, max)
+  const nextValues = getNextSortedValues(values, nextValue, atIndex)
+  if (!hasMinStepsBetweenValues(nextValues, minStepsBetweenThumbs * step)) return undefined
+  return { values: nextValues, index: nextValues.indexOf(nextValue) }
+}
+
+export function sliderStepAmount(event: { key: string; shiftKey: boolean }, step: number) {
+  const skip = PAGE_KEYS.includes(event.key) || (event.shiftKey && ARROW_KEYS.includes(event.key))
+  return step * (skip ? 10 : 1)
+}
+
+export type SliderOrientation = 'horizontal' | 'vertical'
+export type SliderThumbAlignment = 'contain' | 'overflow'
+
+export function sliderOrientationState(
+  orientation: SliderOrientation,
+  dir: 'ltr' | 'rtl' | undefined,
+  inverted: boolean,
+  alignment: SliderThumbAlignment,
+) {
+  if (orientation === 'horizontal') {
+    const fromLeft = (dir !== 'rtl' && !inverted) || (dir !== 'ltr' && inverted)
+    return {
+      startEdge: fromLeft ? 'left' : 'right',
+      endEdge: fromLeft ? 'right' : 'left',
+      direction: fromLeft ? 1 : -1,
+      size: 'width',
+      increasing: fromLeft,
+      slideDirection: fromLeft ? 'from-left' : 'from-right',
+      thumbTransform:
+        !fromLeft && alignment === 'overflow' ? 'translateX(50%)' : 'translateX(-50%)',
+    } as const
+  }
+  const fromBottom = !inverted
+  return {
+    startEdge: fromBottom ? 'bottom' : 'top',
+    endEdge: fromBottom ? 'top' : 'bottom',
+    direction: fromBottom ? 1 : -1,
+    size: 'height',
+    increasing: !fromBottom,
+    slideDirection: fromBottom ? 'from-bottom' : 'from-top',
+    thumbTransform:
+      !fromBottom && alignment === 'overflow' ? 'translateY(-50%)' : 'translateY(50%)',
+  } as const
+}
+
+export function sliderStepDirection(slideDirection: string, key: string) {
+  return BACK_KEYS[slideDirection]!.includes(key) ? -1 : 1
+}
+
+export function createSlideGeometry(axis: 'x' | 'y') {
+  let offset: number | undefined
+  let rect: DOMRect | undefined
+  return {
+    value(
+      event: { clientX: number; clientY: number },
+      slideStart: boolean,
+      options: {
+        element: HTMLElement
+        thumb: HTMLElement
+        contain: boolean
+        output: [number, number]
+      },
+    ) {
+      const { element, thumb, contain, output } = options
+      const bounds = rect || element.getBoundingClientRect()
+      const thumbSize = contain ? (axis === 'x' ? thumb.clientWidth : thumb.clientHeight) : 0
+      const client = axis === 'x' ? event.clientX : event.clientY
+      if (!offset && !slideStart && contain) {
+        const thumbRect = thumb.getBoundingClientRect()
+        offset = client - (axis === 'x' ? thumbRect.left : thumbRect.top)
+      }
+      const start = axis === 'x' ? bounds.left : bounds.top
+      const length = axis === 'x' ? bounds.width : bounds.height
+      const scale = linearScale([0, length - thumbSize], output)
+      rect = bounds
+      const position = slideStart ? client - start - thumbSize / 2 : client - start - (offset ?? 0)
+      return scale(position)
+    },
+    reset() {
+      rect = undefined
+      offset = undefined
+    },
+  }
+}
+
+export function sliderThumbOffset(
+  alignment: SliderThumbAlignment,
+  size: number,
+  percent: number,
+  direction: number,
+) {
+  if (alignment === 'overflow' || !size) return 0
+  return getThumbInBoundsOffset(size, percent, direction)
+}

package/dist/shared/primitives/splitter/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/splitter/arrays.ts

@@ -0,0 +1,6 @@
+export function areEqual<T>(arrayA: T[], arrayB: T[]): boolean {
+  if (arrayA.length !== arrayB.length) return false
+  for (let index = 0; index < arrayA.length; index++)
+    if (arrayA[index] !== arrayB[index]) return false
+  return true
+}

package/dist/shared/primitives/splitter/assert.ts

@@ -0,0 +1,9 @@
+export function assert(
+  expectedCondition: unknown,
+  message = 'Assertion failed!',
+): asserts expectedCondition {
+  if (!expectedCondition) {
+    console.error(message)
+    throw new Error(message)
+  }
+}