@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/internal/pillSurface.ts

@@ -1,93 +0,0 @@
-import {
-  validateBoolean,
-  validateExactString,
-} from './runtimeContract'
-import { resolveSemanticToneBinding } from './semanticTone'
-
-const PILL_KINDS = ['badge', 'chip'] as const
-const PILL_SEVERITIES = [
-  'primary',
-  'secondary',
-  'success',
-  'info',
-  'warn',
-  'danger',
-  'contrast',
-] as const
-const PILL_SIZES = ['xs', 'sm', 'md'] as const
-const PILL_MAX_WIDTHS = ['none', 'sm', 'md'] as const
-const PILL_ICON_MOTIONS = ['static', 'spin'] as const
-
-export type PillSurfaceKind = typeof PILL_KINDS[number]
-export type PillSurfaceSeverity = typeof PILL_SEVERITIES[number]
-export type PillSurfaceSize = typeof PILL_SIZES[number]
-export type PillSurfaceMaxWidth = typeof PILL_MAX_WIDTHS[number]
-export type PillSurfaceIconMotion = typeof PILL_ICON_MOTIONS[number]
-
-export const PILL_ICON_CLASS = 's-pill-icon inline-flex h-[var(--s-pill-icon-size)] w-[var(--s-pill-icon-size)] shrink-0 items-center justify-center'
-export const PILL_ICON_GRAPHIC_CLASS = 's-pill-icon-graphic h-full w-full'
-export const PILL_ICON_SPIN_CLASS = 'animate-spin'
-export const PILL_LABEL_CLASS = 's-pill-label min-w-0'
-export const PILL_LABEL_TRUNCATE_CLASS = 'overflow-hidden text-ellipsis whitespace-nowrap'
-
-export interface PillSurfaceContract {
-  kind: PillSurfaceKind
-  severity: PillSurfaceSeverity
-  size: PillSurfaceSize
-  dot: boolean
-  closable: boolean
-  disabled: boolean
-  truncate: boolean
-  maxWidth: PillSurfaceMaxWidth
-  iconMotion: PillSurfaceIconMotion
-}
-
-export interface PillSurfaceBindings {
-  'data-s-pill-surface': PillSurfaceKind
-  'data-s-tone': PillSurfaceSeverity
-  'data-s-pill-size': PillSurfaceSize
-  'data-s-pill-dot'?: 'true'
-  'data-s-pill-closable'?: 'true'
-  'data-s-pill-disabled'?: 'true'
-  'data-s-pill-truncate'?: 'true'
-  'data-s-pill-max-width'?: Exclude<PillSurfaceMaxWidth, 'none'>
-  'data-s-pill-icon-motion'?: Exclude<PillSurfaceIconMotion, 'static'>
-}
-
-/**
- * Создаёт exact bindings единого pill/feedback presentation owner.
- * Creates exact bindings for the canonical pill/feedback presentation owner.
- */
-export function resolvePillSurfaceBindings(
-  owner: 'SBadge' | 'SChip',
-  contract: PillSurfaceContract,
-): PillSurfaceBindings {
-  const kind = validateExactString(owner, 'pill kind', contract.kind, PILL_KINDS)
-  const toneBinding = resolveSemanticToneBinding(owner, 'severity', contract.severity, PILL_SEVERITIES)
-  const size = validateExactString(owner, 'size', contract.size, PILL_SIZES)
-  const maxWidth = validateExactString(owner, 'maxWidth', contract.maxWidth, PILL_MAX_WIDTHS)
-  const iconMotion = validateExactString(owner, 'iconMotion', contract.iconMotion, PILL_ICON_MOTIONS)
-  const dot = validateBoolean(owner, 'dot', contract.dot)
-  const closable = validateBoolean(owner, 'closable', contract.closable)
-  const disabled = validateBoolean(owner, 'disabled', contract.disabled)
-  const truncate = validateBoolean(owner, 'truncate', contract.truncate)
-
-  if (kind === 'chip' && dot) {
-    throw new TypeError('SChip: dot presentation не поддерживается. / SChip: dot presentation is not supported.')
-  }
-  if (kind === 'badge' && closable) {
-    throw new TypeError('SBadge: closable presentation не поддерживается. / SBadge: closable presentation is not supported.')
-  }
-
-  return {
-    'data-s-pill-surface': kind,
-    ...toneBinding,
-    'data-s-pill-size': size,
-    ...(dot ? { 'data-s-pill-dot': 'true' as const } : {}),
-    ...(closable ? { 'data-s-pill-closable': 'true' as const } : {}),
-    ...(disabled ? { 'data-s-pill-disabled': 'true' as const } : {}),
-    ...(truncate ? { 'data-s-pill-truncate': 'true' as const } : {}),
-    ...(maxWidth === 'none' ? {} : { 'data-s-pill-max-width': maxWidth }),
-    ...(iconMotion === 'static' ? {} : { 'data-s-pill-icon-motion': iconMotion }),
-  }
-}

package/src/internal/pointerInteractionLease.ts

@@ -1,82 +0,0 @@
-export type PointerInteractionCursor = 'col-resize' | 'row-resize'
-
-export interface PointerInteractionLeaseOptions {
-  cursor: PointerInteractionCursor
-}
-
-export interface PointerInteractionLease {
-  release: () => void
-}
-
-interface ActivePointerInteraction {
-  id: symbol
-  cursor: PointerInteractionCursor
-}
-
-const activeInteractions: ActivePointerInteraction[] = []
-let lockedBody: HTMLElement | null = null
-let preservedCursor = ''
-let preservedUserSelect = ''
-
-const applyActiveInteraction = (): void => {
-  const interaction = lastItem(activeInteractions)
-  if (!lockedBody || !interaction) return
-  lockedBody.style.cursor = interaction.cursor
-  lockedBody.style.userSelect = 'none'
-}
-
-const restoreBodyContract = (): void => {
-  if (!lockedBody) return
-  lockedBody.style.cursor = preservedCursor
-  lockedBody.style.userSelect = preservedUserSelect
-  lockedBody = null
-  preservedCursor = ''
-  preservedUserSelect = ''
-}
-
-/**
- * Захватывает общий cursor/user-select контракт на время pointer-взаимодействия.
- * Acquires the shared cursor/user-select contract for one pointer interaction.
- */
-export function acquirePointerInteractionLease(
-  options: PointerInteractionLeaseOptions,
-): PointerInteractionLease {
-  if (typeof document === 'undefined') {
-    throw new Error('pointerInteractionLease: document недоступен вне браузерного runtime')
-  }
-
-  const body = document.body
-  if (activeInteractions.length === 0) {
-    lockedBody = body
-    preservedCursor = body.style.cursor
-    preservedUserSelect = body.style.userSelect
-  } else if (lockedBody !== body) {
-    throw new Error('pointerInteractionLease: document.body изменился во время активного interaction')
-  }
-
-  const interaction: ActivePointerInteraction = {
-    id: Symbol('pointer-interaction'),
-    cursor: options.cursor,
-  }
-  let active = true
-  activeInteractions.push(interaction)
-  applyActiveInteraction()
-
-  return {
-    release: () => {
-      if (!active) return
-      active = false
-      const index = activeInteractions.findIndex(candidate => candidate.id === interaction.id)
-      if (index < 0) {
-        throw new Error('pointerInteractionLease: активный lease отсутствует в реестре')
-      }
-      activeInteractions.splice(index, 1)
-      if (activeInteractions.length === 0) {
-        restoreBodyContract()
-        return
-      }
-      applyActiveInteraction()
-    },
-  }
-}
-import { lastItem } from './es2020'

package/src/internal/runtimeContract.ts

@@ -1,196 +0,0 @@
-export interface BoundedNumberDomain {
-  minimum: number
-  maximum: number
-}
-
-const ASCII_WHITESPACE_PATTERN = /[\t\n\f\r ]/u
-
-function describeRuntimeValue(value: unknown): string {
-  if (typeof value === 'string') return JSON.stringify(value)
-  if (typeof value === 'number') return `number(${String(value)})`
-  if (typeof value === 'bigint') return `bigint(${String(value)})`
-  if (typeof value === 'boolean') return `boolean(${String(value)})`
-  if (typeof value === 'undefined') return 'undefined'
-  if (typeof value === 'symbol') return `symbol(${value.description ?? ''})`
-  if (typeof value === 'function') return 'function'
-  if (value === null) return 'null'
-  return Array.isArray(value) ? 'array' : 'object'
-}
-
-function assertBoundedDomain(
-  owner: string,
-  coordinate: string,
-  domain: BoundedNumberDomain,
-  integer: boolean,
-): void {
-  const validNumbers = Number.isFinite(domain.minimum) && Number.isFinite(domain.maximum)
-  const validIntegerBounds = !integer
-    || (Number.isInteger(domain.minimum) && Number.isInteger(domain.maximum))
-  if (validNumbers && validIntegerBounds && domain.minimum <= domain.maximum) return
-
-  throw new TypeError(integer
-    ? `runtimeContract: границы domain для ${owner}.${coordinate} должны быть целыми числами, `
-      + `где minimum <= maximum; получено minimum=${describeRuntimeValue(domain.minimum)}, `
-      + `maximum=${describeRuntimeValue(domain.maximum)}. / runtimeContract: domain bounds for `
-      + `${owner}.${coordinate} must be integers with minimum <= maximum; received `
-      + `minimum=${describeRuntimeValue(domain.minimum)}, maximum=${describeRuntimeValue(domain.maximum)}.`
-    : `runtimeContract: границы domain для ${owner}.${coordinate} должны быть конечными числами, `
-      + `где minimum <= maximum; получено minimum=${describeRuntimeValue(domain.minimum)}, `
-      + `maximum=${describeRuntimeValue(domain.maximum)}. / runtimeContract: domain bounds for `
-      + `${owner}.${coordinate} must be finite numbers with minimum <= maximum; received `
-      + `minimum=${describeRuntimeValue(domain.minimum)}, maximum=${describeRuntimeValue(domain.maximum)}.`)
-}
-
-function assertExactStringDomain(
-  owner: string,
-  coordinate: string,
-  allowed: readonly string[],
-): void {
-  const uniqueValues = new Set(allowed)
-  if (
-    allowed.length > 0
-    && uniqueValues.size === allowed.length
-    && allowed.every((value) => value.trim().length > 0)
-  ) return
-
-  throw new TypeError(
-    `runtimeContract: domain для ${owner}.${coordinate} должен содержать непустой уникальный список строк. `
-    + `/ runtimeContract: domain for ${owner}.${coordinate} must contain a non-empty unique string list.`,
-  )
-}
-
-/**
- * Проверяет непустую строку без trim/coercion и возвращает исходное значение.
- * Validates a non-empty string without trimming/coercion and returns the original value.
- */
-export function validateNonEmptyString(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-): string {
-  if (typeof value === 'string' && value.trim().length > 0) return value
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть непустой строкой; получено ${received}. `
-    + `/ ${owner}: ${coordinate} must be a non-empty string; received ${received}.`,
-  )
-}
-
-/**
- * Проверяет boolean без truthy/falsy coercion.
- * Validates a boolean without truthy/falsy coercion.
- */
-export function validateBoolean(owner: string, coordinate: string, value: unknown): boolean {
-  if (typeof value === 'boolean') return value
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть boolean; получено ${received}. `
-    + `/ ${owner}: ${coordinate} must be a boolean; received ${received}.`,
-  )
-}
-
-/**
- * Проверяет DOM id по HTML-контракту: непустая строка без ASCII whitespace.
- * Validates an HTML DOM id: a non-empty string without ASCII whitespace.
- */
-export function validateDomId(owner: string, coordinate: string, value: unknown): string {
-  if (typeof value === 'string' && value.length > 0 && !ASCII_WHITESPACE_PATTERN.test(value)) {
-    return value
-  }
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть непустым DOM id без ASCII-пробелов; получено ${received}. `
-    + `/ ${owner}: ${coordinate} must be a non-empty DOM id without ASCII whitespace; `
-    + `received ${received}.`,
-  )
-}
-
-/**
- * Возвращает generated DOM id только при отсутствии явного значения и валидирует обе ветки.
- * Returns a generated DOM id only when the explicit value is absent and validates both branches.
- */
-export function resolveOptionalDomId(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  generatedValue: unknown,
-): string {
-  return value === undefined
-    ? validateDomId(owner, `generated ${coordinate}`, generatedValue)
-    : validateDomId(owner, coordinate, value)
-}
-
-/**
- * Проверяет exact string enum и сохраняет его literal union в return type.
- * Validates an exact string enum and preserves its literal union in the return type.
- */
-export function validateExactString<const Allowed extends readonly string[]>(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  allowed: Allowed,
-): Allowed[number] {
-  assertExactStringDomain(owner, coordinate, allowed)
-  if (typeof value === 'string' && allowed.includes(value)) return value as Allowed[number]
-
-  const expected = `[${allowed.map((candidate) => JSON.stringify(candidate)).join(', ')}]`
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть одним из ${expected}; получено ${received}. `
-    + `/ ${owner}: ${coordinate} must be one of ${expected}; received ${received}.`,
-  )
-}
-
-/**
- * Проверяет конечное число в inclusive domain без coercion.
- * Validates a finite number in an inclusive domain without coercion.
- */
-export function validateBoundedNumber(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  domain: BoundedNumberDomain,
-): number {
-  assertBoundedDomain(owner, coordinate, domain, false)
-  if (
-    typeof value === 'number'
-    && Number.isFinite(value)
-    && value >= domain.minimum
-    && value <= domain.maximum
-  ) return value
-
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть конечным числом в диапазоне `
-    + `[${domain.minimum}, ${domain.maximum}]; получено ${received}. / ${owner}: ${coordinate} `
-    + `must be a finite number in the inclusive range [${domain.minimum}, ${domain.maximum}]; `
-    + `received ${received}.`,
-  )
-}
-
-/**
- * Проверяет целое число в inclusive domain без coercion.
- * Validates an integer in an inclusive domain without coercion.
- */
-export function validateBoundedInteger(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  domain: BoundedNumberDomain,
-): number {
-  assertBoundedDomain(owner, coordinate, domain, true)
-  if (
-    typeof value === 'number'
-    && Number.isInteger(value)
-    && value >= domain.minimum
-    && value <= domain.maximum
-  ) return value
-
-  const received = describeRuntimeValue(value)
-  throw new TypeError(
-    `${owner}: ${coordinate} должен быть целым числом в диапазоне `
-    + `[${domain.minimum}, ${domain.maximum}]; получено ${received}. / ${owner}: ${coordinate} `
-    + `must be an integer in the inclusive range [${domain.minimum}, ${domain.maximum}]; `
-    + `received ${received}.`,
-  )
-}

package/src/internal/runtimeTheme.ts

@@ -1,159 +0,0 @@
-import { onBeforeUnmount, onMounted, readonly, ref, type DeepReadonly, type Ref } from 'vue'
-import {
-  isThemePreference,
-  themeVariants,
-  type ThemeMode,
-  type ThemePreference,
-  type ThemeVariant,
-} from '../theme'
-
-/**
- * Текущее декларативное состояние темы документа.
- * Current declarative document-theme state.
- */
-export interface RuntimeThemeState {
-  /** Точное значение `data-theme`; `null` только при отсутствии явной темы. / Exact `data-theme`; `null` only when no explicit theme is applied. */
-  readonly dataTheme: ThemePreference | null
-  /** Нормализованный режим для runtime adapter. / Normalized mode for a runtime adapter. */
-  readonly mode: ThemeMode
-}
-
-type RuntimeThemeListener = (state: RuntimeThemeState) => void
-
-interface DocumentThemeRuntime {
-  readonly document: Document
-  readonly listeners: Set<RuntimeThemeListener>
-  observer: MutationObserver | null
-  state: RuntimeThemeState
-}
-
-const runtimes = new WeakMap<Document, DocumentThemeRuntime>()
-
-const themeVariantByDataTheme = new Map<ThemePreference, ThemeVariant>(
-  themeVariants.map((variant): [ThemePreference, ThemeVariant] => [variant.dataTheme, variant]),
-)
-
-const statesEqual = (left: RuntimeThemeState, right: RuntimeThemeState): boolean => (
-  left.dataTheme === right.dataTheme && left.mode === right.mode
-)
-
-/**
- * Читает theme contract документа без подписки и DOM-мутаций.
- * Reads the document theme contract without subscribing or mutating DOM.
- */
-export function readRuntimeTheme(targetDocument?: Document): RuntimeThemeState {
-  if (targetDocument === undefined) return { dataTheme: null, mode: 'light' }
-  const root = targetDocument.documentElement
-  const rawDataTheme = root.getAttribute('data-theme')
-  if (rawDataTheme === null) {
-    if (root.classList.contains('dark')) {
-      throw new Error('UI-kit runtime theme: class="dark" требует canonical data-theme.')
-    }
-    return { dataTheme: null, mode: 'light' }
-  }
-  const dataTheme = rawDataTheme
-  if (!isThemePreference(dataTheme)) {
-    throw new TypeError(`UI-kit runtime theme: неизвестный data-theme "${rawDataTheme}".`)
-  }
-  const variant = themeVariantByDataTheme.get(dataTheme)
-  if (variant === undefined) {
-    throw new Error(
-      `UI-kit runtime theme: data-theme="${dataTheme}" отсутствует в canonical theme registry.`,
-    )
-  }
-  const mode = variant.mode
-  const hasDarkClass = root.classList.contains('dark')
-  if (mode === 'dark' && !hasDarkClass) {
-    throw new Error(`UI-kit runtime theme: data-theme="${dataTheme}" требует class="dark".`)
-  }
-  if (mode === 'light' && hasDarkClass) {
-    throw new Error(`UI-kit runtime theme: data-theme="${dataTheme}" конфликтует с class="dark".`)
-  }
-  return {
-    dataTheme,
-    mode,
-  }
-}
-
-const refreshRuntime = (runtime: DocumentThemeRuntime): void => {
-  const nextState = readRuntimeTheme(runtime.document)
-  if (statesEqual(runtime.state, nextState)) return
-  runtime.state = nextState
-  for (const listener of runtime.listeners) listener(nextState)
-}
-
-const createRuntime = (targetDocument: Document): DocumentThemeRuntime => ({
-  document: targetDocument,
-  listeners: new Set(),
-  observer: null,
-  state: readRuntimeTheme(targetDocument),
-})
-
-const startRuntime = (runtime: DocumentThemeRuntime): void => {
-  if (runtime.observer || typeof MutationObserver === 'undefined') return
-  runtime.observer = new MutationObserver(() => refreshRuntime(runtime))
-  runtime.observer.observe(runtime.document.documentElement, {
-    attributes: true,
-    attributeFilter: ['class', 'data-theme'],
-  })
-}
-
-const stopRuntime = (runtime: DocumentThemeRuntime): void => {
-  if (runtime.observer !== null) runtime.observer.disconnect()
-  runtime.observer = null
-  runtimes.delete(runtime.document)
-}
-
-/**
- * Подписывает runtime-интеграцию на единый per-document theme owner.
- * Subscribes a runtime integration to the single per-document theme owner.
- */
-export function subscribeRuntimeTheme(
-  listener: RuntimeThemeListener,
-  targetDocument?: Document,
-): () => void {
-  if (targetDocument === undefined) {
-    listener(readRuntimeTheme())
-    return () => undefined
-  }
-
-  let runtime = runtimes.get(targetDocument)
-  if (runtime === undefined) {
-    runtime = createRuntime(targetDocument)
-    runtimes.set(targetDocument, runtime)
-  }
-  const subscribedRuntime = runtime
-  subscribedRuntime.listeners.add(listener)
-  listener(subscribedRuntime.state)
-  startRuntime(subscribedRuntime)
-
-  let subscribed = true
-  return () => {
-    if (!subscribed) return
-    subscribed = false
-    subscribedRuntime.listeners.delete(listener)
-    if (subscribedRuntime.listeners.size === 0) stopRuntime(subscribedRuntime)
-  }
-}
-
-/**
- * Vue lifecycle adapter для единого runtime theme owner.
- * Vue lifecycle adapter for the canonical runtime theme owner.
- */
-export function useRuntimeTheme(): DeepReadonly<Ref<RuntimeThemeState>> {
-  const targetDocument = typeof document === 'undefined' ? undefined : document
-  const state = ref<RuntimeThemeState>(readRuntimeTheme(targetDocument))
-  let unsubscribe: (() => void) | null = null
-
-  onMounted(() => {
-    unsubscribe = subscribeRuntimeTheme((nextState) => {
-      state.value = nextState
-    }, targetDocument)
-  })
-  onBeforeUnmount(() => {
-    if (unsubscribe !== null) unsubscribe()
-    unsubscribe = null
-  })
-
-  return readonly(state)
-}

package/src/internal/semanticTone.ts

@@ -1,23 +0,0 @@
-import { validateExactString } from './runtimeContract'
-
-/** Единственный internal DOM marker для component-owned visual tone. */
-export const SEMANTIC_TONE_ATTRIBUTE = 'data-s-tone' as const
-
-export type SemanticToneBinding<Tone extends string> = Readonly<{
-  'data-s-tone': Tone
-}>
-
-/**
- * Проверяет component-specific tone vocabulary и создаёт единый namespaced DOM binding.
- * Validates a component-specific tone vocabulary and creates the canonical namespaced DOM binding.
- */
-export function resolveSemanticToneBinding<const Tones extends readonly string[]>(
-  owner: string,
-  coordinate: string,
-  value: unknown,
-  tones: Tones,
-): SemanticToneBinding<Tones[number]> {
-  return {
-    [SEMANTIC_TONE_ATTRIBUTE]: validateExactString(owner, coordinate, value, tones),
-  }
-}

package/src/internal/useBinaryInput.ts

@@ -1,83 +0,0 @@
-import { computed, onMounted, ref, useId, watch, type ComponentPublicInstance } from 'vue'
-
-import { resolveOptionalDomId } from './runtimeContract'
-
-export type BinaryInputOwner = 'SCheckbox' | 'SSwitch'
-
-export interface BinaryInputModelContract {
-  readonly modelValue: boolean
-  readonly readonly: boolean
-  readonly id?: string
-}
-
-export interface BinaryInputOptions {
-  readonly owner: BinaryInputOwner
-  readonly inputName: 'checkbox' | 'switch'
-  readonly props: BinaryInputModelContract
-  readonly indeterminate?: () => boolean
-  readonly emitUpdate: (value: boolean) => void
-  readonly emitClick: (event: MouseEvent) => void
-}
-
-/**
- * Единый runtime owner controlled binary input: identity, value, readonly и native events.
- * Canonical runtime owner for controlled binary input identity, value, readonly, and native events.
- */
-export function useBinaryInput(options: BinaryInputOptions) {
-  const generatedInputId = useId()
-  const inputId = computed(() => resolveOptionalDomId(
-    options.owner,
-    'id',
-    options.props.id,
-    `s-${options.inputName}-${generatedInputId}`,
-  ))
-  const inputEl = ref<HTMLInputElement | null>(null)
-  const checkedValue = computed(() => {
-    if (typeof options.props.modelValue !== 'boolean') {
-      throw new TypeError(`${options.owner}: modelValue must be boolean`)
-    }
-    return options.props.modelValue
-  })
-
-  const applyIndeterminate = (): void => {
-    if (inputEl.value) {
-      inputEl.value.indeterminate = (options.indeterminate?.() ?? false) && !checkedValue.value
-    }
-  }
-  const setInputElement = (element: Element | ComponentPublicInstance | null): void => {
-    if (element !== null && !(element instanceof HTMLInputElement)) {
-      throw new TypeError(`${options.owner}: template ref owner must be the native ${options.inputName} input`)
-    }
-    inputEl.value = element
-    applyIndeterminate()
-  }
-  onMounted(applyIndeterminate)
-  watch([options.indeterminate ?? (() => false), checkedValue], applyIndeterminate)
-
-  const onChange = (event: Event): void => {
-    if (options.props.readonly) return
-    const target = event.currentTarget
-    if (!(target instanceof HTMLInputElement)) {
-      throw new TypeError(
-        `${options.owner}: change event owner must be the native ${options.inputName} input`,
-      )
-    }
-    options.emitUpdate(target.checked)
-  }
-
-  const onClick = (event: MouseEvent): void => {
-    if (options.props.readonly) {
-      event.preventDefault()
-      return
-    }
-    options.emitClick(event)
-  }
-
-  return {
-    checkedValue,
-    inputId,
-    onChange,
-    onClick,
-    setInputElement,
-  } as const
-}