@pyreon/rocketstyle 0.24.5 → 0.24.6

package/src/context/createLocalProvider.ts

@@ -1,97 +0,0 @@
-import { provide } from '@pyreon/core'
-import { signal } from '@pyreon/reactivity'
-import type { PseudoProps } from '../types/pseudo'
-import type { ComponentFn } from '../types/utils'
-import { localContext } from './localContext'
-
-type Props = PseudoProps & Record<string, any>
-
-/**
- * Higher-order component that wraps a component with a LocalProvider,
- * detecting pseudo-states (hover, focus, pressed) via mouse/focus events
- * and broadcasting them through local context to child rocketstyle components.
- *
- * In Pyreon, context is provided via provide(), and state is managed
- * with signals instead of useState.
- */
-const createLocalProvider = (WrappedComponent: ComponentFn<any>) => {
-  const HOCComponent: ComponentFn<Props> = ({
-    onMouseEnter,
-    onMouseLeave,
-    onMouseUp,
-    onMouseDown,
-    onFocus,
-    onBlur,
-    $rocketstate,
-    ...props
-  }) => {
-    const hover = signal(false)
-    const focus = signal(false)
-    const pressed = signal(false)
-
-    const events = {
-      onMouseEnter: (e: MouseEvent) => {
-        hover.set(true)
-        if (onMouseEnter) onMouseEnter(e)
-      },
-      onMouseLeave: (e: MouseEvent) => {
-        hover.set(false)
-        pressed.set(false)
-        if (onMouseLeave) onMouseLeave(e)
-      },
-      onMouseDown: (e: MouseEvent) => {
-        pressed.set(true)
-        if (onMouseDown) onMouseDown(e)
-      },
-      onMouseUp: (e: MouseEvent) => {
-        pressed.set(false)
-        if (onMouseUp) onMouseUp(e)
-      },
-      onFocus: (e: FocusEvent) => {
-        focus.set(true)
-        if (onFocus) onFocus(e)
-      },
-      onBlur: (e: FocusEvent) => {
-        focus.set(false)
-        if (onBlur) onBlur(e)
-      },
-    }
-
-    // Use getters so pseudo-state signals are read lazily by consumers
-    // inside their own reactive scopes — NOT eagerly during parent setup.
-    // Without getters, hover()/focus()/pressed() reads here would register
-    // as dependencies of any parent effect, causing cascading re-renders
-    // on every mouse event.
-    // Resolve $rocketstate if it's a function accessor (from EnhancedComponent)
-    const resolvedState =
-      typeof $rocketstate === 'function' ? $rocketstate() : $rocketstate
-    const updatedState = {
-      ...resolvedState,
-      pseudo: {
-        ...resolvedState?.pseudo,
-        get hover() {
-          return hover()
-        },
-        get focus() {
-          return focus()
-        },
-        get pressed() {
-          return pressed()
-        },
-      },
-    }
-
-    // Provide local context for child rocketstyle components
-    provide(localContext, updatedState)
-
-    return WrappedComponent({
-      ...props,
-      ...events,
-      $rocketstate: updatedState,
-    })
-  }
-
-  return HOCComponent
-}
-
-export default createLocalProvider

package/src/context/localContext.ts

@@ -1,37 +0,0 @@
-import { createContext, useContext } from '@pyreon/core'
-import type { PseudoState } from '../types/pseudo'
-
-type LocalContext = Partial<
-  {
-    pseudo: PseudoState
-  } & Record<string, string>
->
-
-/**
- * Local context for propagating pseudo-state (hover, focus, pressed)
- * and additional styling attributes from a parent provider component
- * to its rocketstyle children.
- */
-const localContext = createContext<LocalContext>({})
-
-const EMPTY_CTX = { pseudo: {} } as LocalContext
-
-/**
- * Retrieves the local pseudo-state context. When a consumer callback
- * is provided, it transforms the raw context; otherwise returns defaults.
- *
- * In Pyreon, components are plain functions that run once — no useMemo needed.
- */
-type UseLocalContext = (consumer: any) => LocalContext
-export const useLocalContext: UseLocalContext = (consumer) => {
-  const ctx = useContext(localContext)
-
-  if (!consumer) return EMPTY_CTX
-
-  const result = consumer((callback: any) => callback(ctx))
-  return { pseudo: {}, ...result }
-}
-
-export { localContext }
-
-export default localContext

package/src/env.d.ts

@@ -1,6 +0,0 @@
-/**
- * Minimal process type — just enough for `process.env.NODE_ENV` checks.
- * Avoids requiring @types/node in consumers that import pyreon source
- * via the `"bun"` export condition.
- */
-declare var process: { env: { NODE_ENV?: string } }

package/src/hoc/index.ts

@@ -1,3 +0,0 @@
-import rocketstyleAttrsHoc from './rocketstyleAttrsHoc'
-
-export { rocketstyleAttrsHoc }

package/src/hoc/rocketstyleAttrsHoc.ts

@@ -1,76 +0,0 @@
-import { render } from '@pyreon/ui-core'
-import { useTheme } from '../hooks'
-import type { Configuration } from '../types/configuration'
-import type { ComponentFn } from '../types/utils'
-import {
-  calculateChainOptions,
-  mergeDescriptors,
-  removeUndefinedProps,
-} from '../utils/attrs'
-
-export type RocketStyleHOC = ({
-  inversed,
-  attrs,
-  priorityAttrs,
-}: Pick<Configuration, 'inversed' | 'attrs' | 'priorityAttrs'>) => (
-  WrappedComponent: ComponentFn<any>,
-) => ComponentFn<any>
-
-/**
- * HOC that resolves the `.attrs()` chain before the inner component renders.
- * Evaluates both regular and priority attrs callbacks with the current theme
- * and mode, then merges the results with explicit props (priority attrs
- * are applied first, regular attrs can be overridden by direct props).
- *
- * In Pyreon, there is no forwardRef — ref flows as a normal prop.
- * Components are plain functions.
- */
-const rocketStyleHOC: RocketStyleHOC = ({ inversed, attrs, priorityAttrs }) => {
-  const calculateAttrs = calculateChainOptions(attrs)
-  const calculatePriorityAttrs = calculateChainOptions(priorityAttrs)
-
-  const Enhanced = (WrappedComponent: ComponentFn<any>) => {
-    const HOCComponent: ComponentFn<any> = (props) => {
-      // IMPORTANT: Do NOT destructure — useTheme returns getter properties.
-      // Destructuring calls getters once and captures static values.
-      // Keep the object reference so properties re-evaluate lazily.
-      const themeAttrs = useTheme({ inversed })
-
-      // Remove undefined props not to override potential default props
-      const filteredProps = removeUndefinedProps(props)
-
-      // Read theme attrs eagerly — .attrs() callbacks run once at mount.
-      // Mode-dependent styling is handled reactively by the $rocketstyle
-      // accessor in EnhancedComponent, not by re-running attrs.
-      const callbackParams = [
-        themeAttrs.theme,
-        { render, mode: themeAttrs.mode, isDark: themeAttrs.isDark, isLight: themeAttrs.isLight },
-      ]
-
-      const prioritizedAttrs = calculatePriorityAttrs([filteredProps, ...callbackParams])
-
-      // Merge via descriptor-copy so reactive getter props on
-      // filteredProps survive the chain. A `{...A, ...B}` spread
-      // would fire every getter on A and B and store the resolved
-      // value, breaking the reactive subscription downstream.
-      // Attrs callbacks legitimately read prop VALUES (e.g.
-      // `({ href }) => ({ tag: href ? 'a' : 'button' })`) — that's
-      // a one-shot read at setup time by design. The pipeline only
-      // needs to preserve reactivity for props the callbacks DON'T
-      // consume, which the descriptor-merge does.
-      const finalAttrs = calculateAttrs([
-        mergeDescriptors(prioritizedAttrs, filteredProps),
-        ...callbackParams,
-      ])
-
-      const finalProps = mergeDescriptors(prioritizedAttrs, finalAttrs, filteredProps)
-
-      return WrappedComponent(finalProps)
-    }
-    return HOCComponent
-  }
-
-  return Enhanced
-}
-
-export default rocketStyleHOC

package/src/hooks/index.ts

@@ -1,4 +0,0 @@
-import usePseudoState from './usePseudoState'
-import useTheme from './useTheme'
-
-export { usePseudoState, useTheme }

package/src/hooks/usePseudoState.ts

@@ -1,79 +0,0 @@
-import { signal } from '@pyreon/reactivity'
-import type { PseudoActions, PseudoState } from '../types/pseudo'
-
-type UsePseudoState = ({
-  onMouseEnter,
-  onMouseLeave,
-  onMouseDown,
-  onMouseUp,
-  onFocus,
-  onBlur,
-}: Partial<PseudoActions>) => {
-  state: Pick<PseudoState, 'hover' | 'focus' | 'pressed'>
-  events: PseudoActions
-}
-
-/**
- * Tracks hover, focus, and pressed pseudo-states via mouse and focus
- * event handlers. Returns the current state flags and wrapped event
- * callbacks that preserve any user-provided handlers.
- *
- * In Pyreon, uses signals instead of useState. Components are plain
- * functions that run once — no useCallback/useMemo needed.
- */
-const usePseudoState: UsePseudoState = ({
-  onBlur,
-  onFocus,
-  onMouseDown,
-  onMouseEnter,
-  onMouseLeave,
-  onMouseUp,
-}) => {
-  const hover = signal(false)
-  const focus = signal(false)
-  const pressed = signal(false)
-
-  const state = {
-    get hover() {
-      return hover()
-    },
-    get focus() {
-      return focus()
-    },
-    get pressed() {
-      return pressed()
-    },
-  }
-
-  const events: PseudoActions = {
-    onMouseEnter: (e) => {
-      hover.set(true)
-      if (onMouseEnter) onMouseEnter(e)
-    },
-    onMouseLeave: (e) => {
-      hover.set(false)
-      pressed.set(false)
-      if (onMouseLeave) onMouseLeave(e)
-    },
-    onMouseDown: (e) => {
-      pressed.set(true)
-      if (onMouseDown) onMouseDown(e)
-    },
-    onMouseUp: (e) => {
-      pressed.set(false)
-      if (onMouseUp) onMouseUp(e)
-    },
-    onFocus: (e) => {
-      focus.set(true)
-      if (onFocus) onFocus(e)
-    },
-    onBlur: (e) => {
-      focus.set(false)
-      if (onBlur) onBlur(e)
-    },
-  }
-
-  return { state, events }
-}
-
-export default usePseudoState

package/src/hooks/useTheme.ts

@@ -1,48 +0,0 @@
-import { useContext } from '@pyreon/core'
-import { THEME_MODES_INVERSED } from '../constants'
-import { context } from '../context/context'
-import type { ThemeModeKeys } from '../types/theme'
-
-type Context = {
-  theme: Record<string, unknown>
-  mode: ThemeModeKeys
-  isDark: boolean
-  isLight: boolean
-}
-
-type UseThemeAttrs = ({ inversed }: { inversed?: boolean | undefined }) => Context
-
-/**
- * Retrieves the current theme object and resolved mode from context.
- *
- * Returns an object with getter properties so that mode/isDark/isLight
- * are evaluated lazily on each access. The context is a ReactiveContext,
- * so useContext returns `() => CoreContextValue` — we call it inside
- * each getter to ensure reactive tracking.
- */
-const useThemeAttrs: UseThemeAttrs = ({ inversed }) => {
-  // ReactiveContext: useContext returns () => CoreContextValue.
-  // Call the getter inside each property getter for reactive tracking.
-  const getCtx = useContext(context)
-
-  return {
-    get theme() {
-      return getCtx().theme ?? ({} as Record<string, unknown>)
-    },
-    get mode() {
-      const ctxMode = getCtx().mode ?? 'light'
-      return inversed ? THEME_MODES_INVERSED[ctxMode] : ctxMode
-    },
-    get isDark() {
-      const ctxDark = getCtx().isDark ?? false
-      return inversed ? !ctxDark : ctxDark
-    },
-    get isLight() {
-      const ctxDark = getCtx().isDark ?? false
-      const isDark = inversed ? !ctxDark : ctxDark
-      return !isDark
-    },
-  }
-}
-
-export default useThemeAttrs

package/src/index.ts

@@ -1,95 +0,0 @@
-import type { TProvider } from './context/context'
-import Provider, { context } from './context/context'
-import type { Rocketstyle } from './init'
-import rocketstyle from './init'
-import type { IsRocketComponent } from './isRocketComponent'
-import isRocketComponent from './isRocketComponent'
-import type { AttrsCb, AttrsHelpers } from './types/attrs'
-import type {
-  ConfigAttrs,
-  ConsumerCb,
-  ConsumerCtxCBValue,
-  ConsumerCtxCb,
-  RocketComponentType,
-  RocketProviderState,
-} from './types/config'
-import type { DefaultProps } from './types/configuration'
-import type {
-  DimensionCallbackParam,
-  DimensionProps,
-  Dimensions,
-  DimensionValue,
-  ExtractDimensionProps,
-  ExtractDimensions,
-  TDKP,
-} from './types/dimensions'
-import type { ComposeParam, GenericHoc } from './types/hoc'
-import type { IRocketStyleComponent, RocketStyleComponent } from './types/rocketstyle'
-import type { RocketStyleInterpolationProps, StylesCb, StylesDefault } from './types/styles'
-import type {
-  ThemeCb,
-  ThemeDefault,
-  ThemeMode,
-  ThemeModeCallback,
-  ThemeModeKeys,
-} from './types/theme'
-import type { ComponentFn, ElementType, ExtractProps, MergeTypes, TObj } from './types/utils'
-
-export type {
-  AttrsCb,
-  AttrsHelpers,
-  ComponentFn,
-  ComposeParam,
-  ConfigAttrs,
-  ConsumerCb,
-  ConsumerCtxCBValue,
-  ConsumerCtxCb,
-  DefaultProps,
-  DimensionCallbackParam,
-  DimensionProps,
-  Dimensions,
-  DimensionValue,
-  ElementType,
-  ExtractDimensionProps,
-  ExtractDimensions,
-  ExtractProps,
-  GenericHoc,
-  IRocketStyleComponent,
-  IsRocketComponent,
-  MergeTypes,
-  RocketComponentType,
-  RocketProviderState,
-  RocketStyleComponent,
-  RocketStyleInterpolationProps,
-  Rocketstyle,
-  StylesCb,
-  StylesDefault,
-  TDKP,
-  ThemeCb,
-  ThemeDefault,
-  ThemeMode,
-  ThemeModeCallback,
-  ThemeModeKeys,
-  TObj,
-  TProvider,
-}
-
-/**
- * Resolve a $rocketstyle value — handles both function accessor and plain object.
- * Use in styled() interpolation functions when $rocketstyle may be a reactive accessor.
- *
- * @example
- * ```ts
- * styled(Component)`
- *   color: ${(props) => resolveTheme(props.$rocketstyle).color};
- * `
- * ```
- */
-export function resolveTheme<T = Record<string, unknown>>(
-  value: (() => T) | T,
-): T {
-  return typeof value === 'function' ? (value as () => T)() : value
-}
-
-export { context, isRocketComponent, Provider, rocketstyle }
-export default rocketstyle

package/src/init.ts

@@ -1,93 +0,0 @@
-import { isEmpty } from '@pyreon/ui-core'
-import { ALL_RESERVED_KEYS, __DEV__ } from './constants'
-import defaultDimensions from './constants/defaultDimensions'
-import rocketComponent from './rocketstyle'
-import type { DefaultDimensions, Dimensions } from './types/dimensions'
-import type { RocketComponent } from './types/rocketComponent'
-import type { ElementType } from './types/utils'
-import {
-  getDimensionsValues,
-  getKeys,
-  getMultipleDimensions,
-  getTransformDimensions,
-} from './utils/dimensions'
-
-export type Rocketstyle = <
-  const D extends Dimensions = DefaultDimensions,
-  UB extends boolean = false,
->({
-  dimensions,
-  useBooleans,
-}?: {
-  dimensions?: D
-  useBooleans?: UB
-}) => <C extends ElementType>({
-  name,
-  component,
-}: {
-  name: string
-  component: C
-}) => ReturnType<RocketComponent<C, {}, {}, D, UB>>
-
-/**
- * Factory initializer for rocketstyle components. Validates dimension
- * configurations against reserved keys, then delegates to the core
- * `rocketComponent` builder with pre-computed dimension metadata.
- */
-type InitErrors = Partial<{
-  component: string
-  name: string
-  dimensions: string
-  invalidDimensions: string
-}>
-
-const validateInit = (name: string, component: unknown, dimensions: Dimensions) => {
-  const errors: InitErrors = {}
-
-  if (!component) {
-    errors.component = 'Parameter `component` is missing in params!'
-  }
-
-  if (!name) {
-    errors.name = 'Parameter `name` is missing in params!'
-  }
-
-  if (isEmpty(dimensions)) {
-    errors.dimensions = 'Parameter `dimensions` is missing in params!'
-  } else {
-    const definedDimensions = getKeys(dimensions)
-    const invalidDimension = ALL_RESERVED_KEYS.some((item) =>
-      definedDimensions.some((d) => d === item),
-    )
-
-    if (invalidDimension) {
-      errors.invalidDimensions = `Some of your \`dimensions\` is invalid and uses reserved static keys which are
-          ${defaultDimensions.toString()}`
-    }
-  }
-
-  if (!isEmpty(errors)) {
-    throw Error(JSON.stringify(errors))
-  }
-}
-
-const rocketstyle = (({ dimensions = defaultDimensions, useBooleans = false } = {}) =>
-  ({ name, component }: { name: string; component: any }) => {
-    if (__DEV__) {
-      validateInit(name, component, dimensions)
-    }
-
-    return (rocketComponent as any)({
-      name,
-      component,
-      useBooleans,
-      dimensions,
-      dimensionKeys: getKeys(dimensions),
-      dimensionValues: getDimensionsValues(dimensions),
-      multiKeys: getMultipleDimensions(dimensions),
-      transformKeys: getTransformDimensions(dimensions),
-      styled: true,
-    })
-  }) as unknown as Rocketstyle
-
-export default rocketstyle

package/src/isRocketComponent.ts

@@ -1,16 +0,0 @@
-export type IsRocketComponent = <T>(component: T) => boolean
-
-/** Runtime type guard — checks if a component was created by `rocketstyle()`. */
-const isRocketComponent: IsRocketComponent = (component) => {
-  if (
-    component &&
-    (typeof component === 'object' || typeof component === 'function') &&
-    Object.hasOwn(component as object, 'IS_ROCKETSTYLE')
-  ) {
-    return true
-  }
-
-  return false
-}
-
-export default isRocketComponent