@pyreon/ui-core 0.24.5 → 0.24.6

package/src/render.tsx

@@ -1,50 +0,0 @@
-import type { ComponentFn, Props, VNodeChild } from '@pyreon/core'
-import { h } from '@pyreon/core'
-
-type RenderProps<T extends Record<string, unknown> | undefined> = (props: Partial<T>) => VNodeChild
-
-/**
- * Flexible element renderer that handles multiple content types:
- * - Primitives (string, number) — returned as-is
- * - Arrays — returned as-is
- * - Component functions — created via h()
- * - VNode objects — returned as-is (with props merged if provided)
- * - Render props (functions) — called with attachProps
- * - Falsy values — return null
- */
-export type Render = <T extends Record<string, any> | undefined>(
-  content?: ComponentFn | string | VNodeChild | VNodeChild[] | RenderProps<T>,
-  attachProps?: T,
-) => VNodeChild
-
-const render: Render = (content, attachProps) => {
-  if (!content) return null
-
-  const t = typeof content
-  if (t === 'string' || t === 'number' || t === 'boolean' || t === 'bigint') {
-    return content as VNodeChild
-  }
-
-  if (Array.isArray(content)) {
-    return content as VNodeChild
-  }
-
-  if (typeof content === 'function') {
-    // Extract key from props — it's a VNode concept, not a component prop.
-    // Passing key inside props causes JSX runtime warnings.
-    if (attachProps && 'key' in attachProps) {
-      const { key: _key, ...rest } = attachProps
-      return h(content as string | ComponentFn, rest as Props)
-    }
-    return h(content as string | ComponentFn, (attachProps ?? {}) as Props)
-  }
-
-  // VNode object — return directly
-  if (typeof content === 'object') {
-    return content as VNodeChild
-  }
-
-  return content as VNodeChild
-}
-
-export default render

package/src/types.ts

@@ -1,5 +0,0 @@
-export interface Breakpoints {
-  [key: string]: number
-}
-
-export type BreakpointKeys = keyof Breakpoints

package/src/useStableValue.ts

@@ -1,21 +0,0 @@
-import { signal } from '@pyreon/reactivity'
-import isEqual from './isEqual'
-
-/**
- * Returns a referentially stable version of `value`. The returned reference
- * only changes when the value is no longer deeply equal to the previous one.
- *
- * Pyreon equivalent of the React useStableValue hook — uses a signal
- * internally to hold the stable reference.
- */
-const useStableValue = <T>(value: T): T => {
-  const ref = signal(value)
-
-  if (!isEqual(ref.peek(), value)) {
-    ref.set(value)
-  }
-
-  return ref.peek()
-}
-
-export default useStableValue

package/src/utils.ts

@@ -1,187 +0,0 @@
-/**
- * Returns a copy of `obj` without the specified keys.
- *
- * Accepts either an array of keys (builds a Set internally) or a
- * pre-built `Set<string>` for hot paths where the same key list is
- * reused across many calls (avoids per-call Set allocation).
- *
- * Copies own property DESCRIPTORS (not values) so that getter-shaped
- * properties — produced by `makeReactiveProps` in `@pyreon/core` for
- * compiler-emitted `<Comp prop={signal()}>` — survive the copy with
- * their reactive subscription intact. For data properties the
- * behaviour is identical to value-copying.
- */
-export const omit = <T extends Record<string, any>>(
-  obj: T | null | undefined,
-  keys?: readonly (string | keyof T)[] | Set<string>,
-): Partial<T> => {
-  if (obj == null) return {} as Partial<T>
-  const descriptors = Object.getOwnPropertyDescriptors(obj)
-  if (!keys || (keys instanceof Set ? keys.size === 0 : keys.length === 0)) {
-    return Object.defineProperties({} as Partial<T>, descriptors)
-  }
-  const keysSet = keys instanceof Set ? keys : new Set(keys as readonly string[])
-  const result: Record<string, any> = {}
-  for (const key of Object.keys(descriptors)) {
-    if (!keysSet.has(key)) {
-      Object.defineProperty(result, key, descriptors[key]!)
-    }
-  }
-  return result as Partial<T>
-}
-
-/**
- * Returns a copy of `obj` containing only the specified keys.
- *
- * See `omit` above — same descriptor-preserving semantics: getter-
- * shaped properties survive the copy with reactive subscription
- * intact. For data properties the behaviour is identical to
- * value-copying.
- */
-export const pick = <T extends Record<string, any>>(
-  obj: T | null | undefined,
-  keys?: readonly (string | keyof T)[],
-): Partial<T> => {
-  if (obj == null) return {} as Partial<T>
-  if (!keys || keys.length === 0) {
-    return Object.defineProperties(
-      {} as Partial<T>,
-      Object.getOwnPropertyDescriptors(obj),
-    )
-  }
-  const result: Record<string, any> = {}
-  for (const key of keys) {
-    const k = key as string
-    const descriptor = Object.getOwnPropertyDescriptor(obj, k)
-    if (descriptor) {
-      Object.defineProperty(result, k, descriptor)
-    }
-  }
-  return result as Partial<T>
-}
-
-const PATH_RE = /[^.[\]]+/g
-
-const parsePath = (path: string | string[]): string[] => {
-  if (Array.isArray(path)) return path
-  const parts = path.match(PATH_RE)
-  return parts ?? []
-}
-
-const isUnsafeKey = (key: string): boolean =>
-  key === '__proto__' || key === 'prototype' || key === 'constructor'
-
-export const get = (obj: any, path: string | string[], defaultValue?: any): any => {
-  const keys = parsePath(path)
-  let result = obj
-  for (const key of keys) {
-    if (result == null || isUnsafeKey(key)) return defaultValue
-    result = result[key]
-  }
-  return result === undefined ? defaultValue : result
-}
-
-export const set = (
-  obj: Record<string, any>,
-  path: string | string[],
-  value: any,
-): Record<string, any> => {
-  const keys = parsePath(path)
-  let current = obj
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i] as string
-    if (isUnsafeKey(key)) return obj
-    const nextKey = keys[i + 1] as string
-    if (isUnsafeKey(nextKey)) return obj
-    if (current[key] == null) {
-      current[key] = /^\d+$/.test(nextKey) ? [] : {}
-    }
-    current = current[key]
-  }
-  const lastKey = keys[keys.length - 1]
-  if (lastKey != null && !isUnsafeKey(lastKey)) {
-    current[lastKey] = value
-  }
-  return obj
-}
-
-export const throttle = <T extends (...args: any[]) => any>(
-  fn: T,
-  wait: number = 0,
-  options?: { leading?: boolean; trailing?: boolean },
-): T & { cancel: () => void } => {
-  const leading = options?.leading !== false
-  const trailing = options?.trailing !== false
-  let lastCallTime: number | undefined
-  let timeoutId: ReturnType<typeof setTimeout> | undefined
-  let lastArgs: any[] | undefined
-
-  const invoke = (args: any[]) => {
-    lastCallTime = Date.now()
-    fn(...args)
-  }
-
-  const startTrailingTimer = (args: any[], delay: number) => {
-    lastArgs = args
-    if (timeoutId !== undefined) return
-    timeoutId = setTimeout(() => {
-      timeoutId = undefined
-      if (lastArgs) {
-        invoke(lastArgs)
-        lastArgs = undefined
-      }
-    }, delay)
-  }
-
-  const throttled = (...args: any[]) => {
-    const now = Date.now()
-    const elapsed = lastCallTime === undefined ? wait : now - lastCallTime
-    if (elapsed >= wait) {
-      if (leading) {
-        invoke(args)
-      } else {
-        lastCallTime = now
-        if (trailing) startTrailingTimer(args, wait)
-      }
-    } else if (trailing) {
-      startTrailingTimer(args, wait - elapsed)
-    }
-  }
-
-  throttled.cancel = () => {
-    if (timeoutId !== undefined) {
-      clearTimeout(timeoutId)
-      timeoutId = undefined
-    }
-    lastArgs = undefined
-    lastCallTime = undefined
-  }
-
-  return throttled as T & { cancel: () => void }
-}
-
-const isPlainObject = (value: unknown): value is Record<string, any> =>
-  value !== null &&
-  typeof value === 'object' &&
-  !Array.isArray(value) &&
-  Object.getPrototypeOf(value) === Object.prototype
-
-export const merge = <T extends Record<string, any>>(
-  target: T,
-  ...sources: Record<string, any>[]
-): T => {
-  for (const source of sources) {
-    if (source == null) continue
-    for (const key of Object.keys(source)) {
-      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue
-      const targetVal = (target as Record<string, unknown>)[key]
-      const sourceVal = source[key]
-      if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
-        ;(target as Record<string, unknown>)[key] = merge({ ...targetVal }, sourceVal)
-      } else {
-        ;(target as Record<string, unknown>)[key] = sourceVal
-      }
-    }
-  }
-  return target
-}