@pyreon/rocketstyle 0.24.4 → 0.24.6

package/src/utils/attrs.ts

@@ -1,181 +0,0 @@
-import type { MultiKeys } from '../types/dimensions'
-
-// --------------------------------------------------------
-// remove undefined props
-// --------------------------------------------------------
-/**
- * Strips keys with `undefined` values so they don't shadow default props during merging.
- *
- * Copies own property DESCRIPTORS rather than values so that reactive
- * getter-shaped props (compiler-emitted `_rp(() => signal())` converted
- * to getters by `makeReactiveProps`) survive the pipeline with their
- * subscription intact. Reading `props[key]` here would fire the getter
- * at HOC setup time (outside any tracking scope) and collapse the prop
- * to a static value — every downstream JSX accessor that reads
- * `props.x` would see the captured-once value, not the live signal.
- *
- * For getter descriptors we keep the descriptor as-is (the
- * undefined-filter doesn't apply — we can't peek into the getter
- * without firing it). For data descriptors we drop entries whose
- * value is `undefined` to preserve the original merge semantics.
- */
-type RemoveUndefinedProps = <T extends Record<string, any>>(props: T) => Partial<T>
-
-export const removeUndefinedProps: RemoveUndefinedProps = (props) => {
-  const result: Partial<typeof props> = {}
-  const descriptors = Object.getOwnPropertyDescriptors(props)
-  for (const key of Object.keys(descriptors)) {
-    const d = descriptors[key]!
-    if (d.get || d.value !== undefined) {
-      Object.defineProperty(result, key, d)
-    }
-  }
-  return result
-}
-
-// --------------------------------------------------------
-// merge descriptors
-// --------------------------------------------------------
-/**
- * Like `Object.assign(target, ...sources)` but copies own property
- * DESCRIPTORS instead of reading + writing values. Later sources
- * override earlier ones (same semantics as spread / Object.assign).
- *
- * Required for reactive-prop preservation through the rocketstyle
- * pipeline: a plain `{ ...A, ...B }` spread fires every getter on A
- * and B and stores the resolved value, breaking the reactive
- * subscription. This helper copies descriptors so getters survive
- * the merge.
- */
-export const mergeDescriptors = (
-  ...sources: ReadonlyArray<Record<string, any> | null | undefined>
-): Record<string, any> => {
-  const result: Record<string, any> = {}
-  for (const source of sources) {
-    if (!source) continue
-    const descriptors = Object.getOwnPropertyDescriptors(source)
-    for (const key of Object.keys(descriptors)) {
-      Object.defineProperty(result, key, descriptors[key]!)
-    }
-  }
-  return result
-}
-
-// --------------------------------------------------------
-// pick styled props
-// --------------------------------------------------------
-/** Picks only the props whose keys exist in the dimension keywords lookup and have truthy values. */
-export const pickStyledAttrs = <
-  T extends Record<string, any>,
-  K extends Record<string, true | undefined>,
->(
-  props: T,
-  keywords: K,
-): { [I in keyof K & keyof T]: T[I] } => {
-  // Direct `for...in` avoids the `Object.keys(props)` array allocation
-  // that `for (const key of Object.keys(props))` paid on every render.
-  // The hot path is rocketstyle's `EnhancedComponent` body — fires once
-  // per render of every rocketstyle-wrapped component. Ported from
-  // vitus-labs `00fdadc2`.
-  const result: Record<string, unknown> = {}
-  for (const key in props) {
-    if (keywords[key] && props[key]) result[key] = props[key]
-  }
-  return result as { [I in keyof K & keyof T]: T[I] }
-}
-
-// --------------------------------------------------------
-// combine values
-// --------------------------------------------------------
-/**
- * Returns a curried function that evaluates an array of `.attrs()` callbacks,
- * spreading each result into a single merged props object via `Object.assign`.
- */
-type OptionFunc<A> = (...arg: A[]) => Record<string, unknown>
-type CalculateChainOptions = <A>(
-  options?: OptionFunc<A>[],
-) => (args: A[]) => ReturnType<OptionFunc<A>>
-
-export const calculateChainOptions: CalculateChainOptions = (options) => (args) => {
-  if (!options || options.length === 0) return {}
-
-  return options.reduce<Record<string, unknown>>(
-    (acc, item) => Object.assign(acc, item(...args)),
-    {},
-  )
-}
-
-// --------------------------------------------------------
-// get style attributes
-// --------------------------------------------------------
-/**
- * Resolves the active value for each styling dimension from component props.
- * First checks for explicit prop values (string, number, or array for multi-keys),
- * then falls back to boolean shorthand props when `useBooleans` is enabled.
- */
-type CalculateStylingAttrs = ({
-  useBooleans,
-  multiKeys,
-}: {
-  useBooleans?: boolean
-  multiKeys?: MultiKeys
-}) => ({
-  props,
-  dimensions,
-}: {
-  props: Record<string, unknown>
-  dimensions: Record<string, unknown>
-}) => Record<string, any>
-export const calculateStylingAttrs: CalculateStylingAttrs =
-  ({ useBooleans, multiKeys }) =>
-  ({ props, dimensions }) => {
-    const result: Record<string, any> = {}
-
-    // (1) find dimension keys values & initialize
-    for (const item in dimensions) {
-      const pickedProp = props[item]
-      const t = typeof pickedProp
-
-      if (multiKeys?.[item] && Array.isArray(pickedProp)) {
-        result[item] = pickedProp
-      } else if (t === 'string' || t === 'number') {
-        result[item] = pickedProp
-      } else {
-        result[item] = undefined
-      }
-    }
-
-    // (2) if booleans are being used let's find the rest
-    // Use `in` operator on the dimension map instead of allocating
-    // a new Set per dimension — the map is already an object with
-    // the keywords as keys.
-    if (useBooleans) {
-      for (const key in result) {
-        if (result[key]) continue // already assigned
-
-        const dimensionMap = dimensions[key] as Record<string, unknown>
-        const isMultiKey = multiKeys?.[key]
-        let newDimensionValue: string | string[] | undefined
-
-        if (isMultiKey) {
-          const matches: string[] = []
-          for (const propKey in props) {
-            if (propKey in dimensionMap) matches.push(propKey)
-          }
-          newDimensionValue = matches.length > 0 ? matches : undefined
-        } else {
-          // Iterate props to find last matching keyword
-          // (last wins for priority)
-          for (const k in props) {
-            if (k in dimensionMap && props[k]) {
-              newDimensionValue = k
-            }
-          }
-        }
-
-        result[key] = newDimensionValue
-      }
-    }
-
-    return result
-  }

package/src/utils/chaining.ts

@@ -1,58 +0,0 @@
-type Func = (...args: any) => Record<string, unknown>
-type Obj = Record<string, unknown>
-
-// --------------------------------------------------------
-// Chain Options
-// --------------------------------------------------------
-/**
- * Appends a new option (function or plain object) to an existing chain
- * of option callbacks. Objects are wrapped in a thunk for uniform handling.
- */
-type ChainOptions = (opts: Obj | Func | undefined, defaultOpts: Func[]) => Func[]
-
-export const chainOptions: ChainOptions = (opts, defaultOpts = []) => {
-  const result = [...defaultOpts]
-
-  if (typeof opts === 'function') result.push(opts)
-  else if (typeof opts === 'object') result.push(() => opts)
-
-  return result
-}
-
-// --------------------------------------------------------
-// Chain Or Options
-// --------------------------------------------------------
-/**
- * For each key, picks the new value if truthy, otherwise falls back
- * to the default. Used for config keys that replace rather than merge.
- */
-type ChainOrOptions = (
-  keys: readonly string[],
-  opts: Obj,
-  defaultOpts: Obj,
-) => Record<string, unknown>
-
-export const chainOrOptions: ChainOrOptions = (keys, opts, defaultOpts) =>
-  keys.reduce((acc, item) => ({ ...acc, [item]: opts[item] || defaultOpts[item] }), {})
-
-// --------------------------------------------------------
-// Chain Reserved Options
-// --------------------------------------------------------
-/**
- * Chains option callbacks for reserved dimension and styling keys,
- * delegating to `chainOptions` for each key individually.
- */
-type ChainReservedKeyOptions = (
-  keys: readonly string[],
-  opts: Record<string, Obj | Func>,
-  defaultOpts: Record<string, Func[]>,
-) => Record<string, ReturnType<typeof chainOptions>>
-
-export const chainReservedKeyOptions: ChainReservedKeyOptions = (keys, opts, defaultOpts) =>
-  keys.reduce(
-    (acc, item) => ({
-      ...acc,
-      [item]: chainOptions(opts[item], defaultOpts[item] ?? []),
-    }),
-    {},
-  )

package/src/utils/collection.ts

@@ -1,9 +0,0 @@
-// --------------------------------------------------------
-// Remove Nullable values
-// --------------------------------------------------------
-/** Filters out entries with `null`, `undefined`, or `false` values from an object. */
-type RemoveNullableValues = (obj: Record<string, any>) => Record<string, any>
-export const removeNullableValues: RemoveNullableValues = (obj) =>
-  Object.entries(obj)
-    .filter(([, v]) => v != null && v !== false)
-    .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {})

package/src/utils/compose.ts

@@ -1,11 +0,0 @@
-/**
- * Extracts HOC functions from the compose configuration object,
- * filters out non-function entries, and reverses them so the
- * outermost HOC in the chain wraps first (inside-out composition).
- */
-type CalculateHocsFuncs = (options: Record<string, any>) => ((arg: any) => any)[]
-
-export const calculateHocsFuncs: CalculateHocsFuncs = (options = {}) =>
-  Object.values(options)
-    .filter((item) => typeof item === 'function')
-    .reverse()

package/src/utils/dimensions.ts

@@ -1,126 +0,0 @@
-import { get, isEmpty, set } from '@pyreon/ui-core'
-import type { Dimensions, DimensionValue, MultiKeys } from '../types/dimensions'
-
-// --------------------------------------------------------
-// Is value a valid key
-// --------------------------------------------------------
-/** Checks whether a dimension value is defined and not explicitly disabled (false). */
-type IsValidKey = (value: any) => boolean
-export const isValidKey: IsValidKey = (value) =>
-  value !== undefined && value !== null && value !== false
-
-// --------------------------------------------------------
-// Is value a multi key
-// --------------------------------------------------------
-/** Determines if a dimension value is a multi-key config object, returning [isMulti, propName]. */
-type IsMultiKey = (value: string | Record<string, unknown>) => [boolean, string]
-export const isMultiKey: IsMultiKey = (value) => {
-  if (typeof value === 'object' && value !== null) return [true, get(value, 'propName') as string]
-  return [false, value]
-}
-
-// --------------------------------------------------------
-// calculate dimensions map
-// --------------------------------------------------------
-/**
- * Builds a two-level map (`keysMap`) of dimension -> option -> true,
- * and a flat `keywords` lookup of all prop names reserved by dimensions
- * (including boolean shorthand keys when `useBooleans` is enabled).
- */
-type GetDimensionsMap = <T extends Record<string, any>>({
-  themes,
-  useBooleans,
-}: {
-  themes: T
-  useBooleans?: boolean
-}) => { keysMap: Record<string, any>; keywords: Record<string, any> }
-
-export const getDimensionsMap: GetDimensionsMap = ({ themes, useBooleans }) => {
-  const result = {
-    keysMap: {} as Record<string, any>,
-    keywords: {} as Record<string, any>,
-  }
-
-  if (isEmpty(themes)) return result
-
-  return Object.entries(themes).reduce((accumulator, [key, value]) => {
-    const { keysMap, keywords } = accumulator
-    keywords[key] = true
-
-    Object.entries(value).forEach(([itemKey, itemValue]) => {
-      if (!isValidKey(itemValue)) return
-
-      if (useBooleans) {
-        keywords[itemKey] = true
-      }
-
-      set(keysMap, [key, itemKey], true)
-    })
-
-    return accumulator
-  }, result)
-}
-
-// --------------------------------------------------------
-// simple object getters
-// --------------------------------------------------------
-/** Returns the keys of an object with proper typing. */
-type GetKeys = <T extends Record<string, unknown>>(obj: T) => Array<keyof T>
-export const getKeys: GetKeys = (obj) => Object.keys(obj)
-
-type GetValues = <T extends Record<string, unknown>, K extends keyof T>(obj: T) => T[K][]
-export const getValues = (<T extends Record<string, unknown>>(obj: T) =>
-  Object.values(obj)) as GetValues
-
-// --------------------------------------------------------
-// get dimensions values array
-// --------------------------------------------------------
-/** Extracts the prop name from each dimension value, unwrapping multi-key config objects. */
-type ValueType<T> = T extends string ? T : T[][0]
-type GetDimensionsValues = <T extends Dimensions, K extends keyof T>(obj: T) => ValueType<T[K]>[]
-
-export const getDimensionsValues = (<T extends Dimensions>(obj: T) =>
-  getValues(obj).map((item: DimensionValue) => {
-    if (typeof item === 'object') {
-      return item.propName as string
-    }
-
-    return item
-  })) as GetDimensionsValues
-
-// --------------------------------------------------------
-// get multiple dimensions map
-// --------------------------------------------------------
-/** Builds a lookup of dimension prop names that accept multiple simultaneous values. */
-type GetMultipleDimensions = <T extends Dimensions>(obj: T) => MultiKeys<T>
-
-export const getMultipleDimensions: GetMultipleDimensions = (obj) =>
-  getValues(obj).reduce(
-    (accumulator, value: DimensionValue) => {
-      if (typeof value === 'object') {
-        if (value.multi === true) accumulator[value.propName] = true
-      }
-
-      return accumulator
-    },
-    {} as Record<string, true>,
-  )
-
-// --------------------------------------------------------
-// get transform dimensions map
-// --------------------------------------------------------
-/** Builds a lookup of dimension prop names that are transform dimensions (evaluated last with function values). */
-type TransformKeys = Partial<Record<string, true>>
-type GetTransformDimensions = <T extends Dimensions>(obj: T) => TransformKeys
-
-export const getTransformDimensions: GetTransformDimensions = (obj) =>
-  getValues(obj).reduce(
-    (accumulator, value: DimensionValue) => {
-      if (typeof value === 'object') {
-        if (value.transform === true) accumulator[value.propName] = true
-      }
-
-      return accumulator
-    },
-    {} as Record<string, true>,
-  )

package/src/utils/statics.ts

@@ -1,44 +0,0 @@
-import { isEmpty } from '@pyreon/ui-core'
-import { STATIC_KEYS } from '../constants'
-
-// --------------------------------------------------------
-// helpers for create statics chaining methods on component
-// --------------------------------------------------------
-/**
- * Attaches chaining static methods (e.g. `.states()`, `.sizes()`, `.theme()`)
- * to a component. Each method calls `cloneAndEnhance` with the corresponding key.
- */
-type CreateStaticsChainingEnhancers = <O extends Record<string, any>, DK extends string[]>(props: {
-  context: Record<string, any>
-  dimensionKeys: DK
-  func: (defaultOpts: O, opts: any) => void
-  options: O
-}) => void
-
-export const createStaticsChainingEnhancers: CreateStaticsChainingEnhancers = ({
-  context,
-  dimensionKeys,
-  func,
-  options,
-}) => {
-  const keys = [...dimensionKeys, ...STATIC_KEYS]
-
-  keys.forEach((item) => {
-    context[item] = (props: any) => func(options, { [item]: props })
-  })
-}
-
-// --------------------------------------------------------
-// helpers for create statics on component
-// --------------------------------------------------------
-/** Copies user-defined static properties onto the component's `meta` object. */
-type CreateStaticsEnhancers = (params: {
-  context: Record<string, any>
-  options: Record<string, any>
-}) => void
-
-export const createStaticsEnhancers: CreateStaticsEnhancers = ({ context, options }) => {
-  if (!isEmpty(options)) {
-    Object.assign(context, options)
-  }
-}

package/src/utils/styles.ts

@@ -1,18 +0,0 @@
-import { config } from '@pyreon/ui-core'
-import type { StylesCbArray } from '../types/styles'
-
-// --------------------------------------------------------
-// Calculate styles
-// --------------------------------------------------------
-/**
- * Evaluates an array of style callback functions with the configured
- * `css` tagged-template helper, producing the final CSS interpolations
- * to be passed into the styled-component template literal.
- */
-type CalculateStyles = (styles: StylesCbArray | undefined) => ReturnType<StylesCbArray[number]>[]
-
-export const calculateStyles: CalculateStyles = (styles) => {
-  if (!styles) return []
-
-  return styles.map((item) => item(config.css as Parameters<typeof item>[0]))
-}

package/src/utils/theme.ts

@@ -1,211 +0,0 @@
-import { config, isEmpty, merge } from '@pyreon/ui-core'
-import type { ThemeModeCallback } from '../types/theme'
-import { removeNullableValues } from './collection'
-import { isMultiKey } from './dimensions'
-
-// --------------------------------------------------------
-// Theme Mode Callback
-// --------------------------------------------------------
-const MODE_CALLBACK_BRAND = Symbol.for('pyreon.themeModeCallback')
-
-/** Creates a mode-switching function that returns the light or dark value based on the active mode. */
-export const themeModeCallback: ThemeModeCallback = (light, dark) => {
-  const fn = (mode: string) => {
-    if (!mode || mode === 'light') return light
-    return dark
-  }
-  ;(fn as unknown as Record<string, unknown>).__brand = MODE_CALLBACK_BRAND
-  return fn
-}
-
-// --------------------------------------------------------
-// Theme Mode Callback Check
-// --------------------------------------------------------
-/** Detects whether a value is a `themeModeCallback` function via Symbol brand. */
-type IsModeCallback = (value: unknown) => boolean
-const isModeCallback: IsModeCallback = (value: unknown) =>
-  typeof value === 'function' &&
-  (value as unknown as Record<string, unknown>).__brand === MODE_CALLBACK_BRAND
-
-// --------------------------------------------------------
-// Get Theme From Chain
-// --------------------------------------------------------
-/** Reduces an array of chained `.theme()` callbacks into a single merged theme object. */
-type OptionFunc = (...arg: any) => Record<string, unknown>
-type GetThemeFromChain = (
-  options: OptionFunc[] | undefined | null,
-  theme: Record<string, any>,
-) => ReturnType<OptionFunc>
-
-export const getThemeFromChain: GetThemeFromChain = (options, theme) => {
-  const result = {}
-  if (!options || isEmpty(options)) return result
-
-  return options.reduce(
-    (acc, item) => merge(acc, item(theme, themeModeCallback, config.css)),
-    result,
-  )
-}
-
-// --------------------------------------------------------
-// calculate dimension themes
-// --------------------------------------------------------
-/**
- * Computes the theme object for each dimension by evaluating its
- * chained callbacks against the global theme, then strips nullable values.
- */
-type GetDimensionThemes = (
-  theme: Record<string, any>,
-  options: Record<string, any>,
-) => Record<string, any>
-
-export const getDimensionThemes: GetDimensionThemes = (theme, options) => {
-  const dims = options.dimensions
-  if (isEmpty(dims)) return {}
-
-  const result: Record<string, any> = {}
-
-  for (const key in dims) {
-    const [, dimension] = isMultiKey(dims[key] as string | Record<string, unknown>)
-    const helper = options[key]
-
-    if (Array.isArray(helper) && helper.length > 0) {
-      result[dimension] = removeNullableValues(getThemeFromChain(helper, theme))
-    }
-  }
-
-  return result
-}
-
-// --------------------------------------------------------
-// combine values
-// --------------------------------------------------------
-/** Reduces an array of option callbacks by calling each with the given args and deep-merging results. */
-type CalculateChainOptions = (
-  options: OptionFunc[] | undefined | null,
-  args: any[],
-) => Record<string, any>
-
-export const calculateChainOptions: CalculateChainOptions = (options, args) => {
-  const result = {}
-  if (!options || isEmpty(options)) return result
-
-  return options.reduce((acc, item) => merge(acc, item(...args)), result)
-}
-
-// --------------------------------------------------------
-// generate theme
-// --------------------------------------------------------
-/**
- * Generates the final theme object by starting with the base theme
- * and merging in dimension-specific theme slices based on the current
- * rocketstate (active dimension values). Supports multi-key dimensions.
- *
- * Transform dimensions (marked with `transform: true`) are evaluated last.
- * Their values are functions that receive the fully accumulated theme and
- * return overrides — enabling derived styles like "outlined" or "inversed".
- */
-export type GetTheme = (params: {
-  rocketstate: Record<string, string | string[]>
-  themes: Record<string, Record<string, any>>
-  baseTheme: Record<string, any>
-  transformKeys?: Partial<Record<string, true>>
-  /** App theme from context — passed to transform dimension callbacks. */
-  appTheme?: Record<string, any>
-}) => Record<string, unknown>
-
-// Shared empty object for pseudo-state defaults — allocated once, reused by
-// every getTheme call. Frozen to prevent accidental mutation.
-const EMPTY_PSEUDO: Record<string, never> = Object.freeze({}) as Record<string, never>
-
-export const getTheme: GetTheme = ({ rocketstate, themes, baseTheme, transformKeys, appTheme }) => {
-  // Spread baseTheme into result — this is unavoidable (we must not mutate
-  // the cached baseTheme). But we merge dimension slices in-place onto
-  // finalTheme instead of creating a new {} target each merge() call.
-  const finalTheme: Record<string, any> = { ...baseTheme }
-  type TransformFn = (
-    currentTheme: Record<string, any>,
-    currentAppTheme: Record<string, any>,
-    mode: typeof themeModeCallback,
-    cssFn: typeof config.css,
-  ) => Record<string, any>
-  const deferredTransforms: TransformFn[] = []
-
-  for (const key in rocketstate) {
-    const value = rocketstate[key]
-    if (value == null) continue
-    const keyTheme: Record<string, any> = themes[key] ?? {}
-    const isTransform = transformKeys?.[key]
-
-    const mergeValue = (item: string) => {
-      const val = keyTheme[item]
-      if (val == null) return
-      if (isTransform && typeof val === 'function') {
-        deferredTransforms.push(val as TransformFn)
-      } else {
-        // Merge in-place onto finalTheme — avoids allocating a fresh {}
-        // as merge target on every dimension slice.
-        merge(finalTheme, val)
-      }
-    }
-
-    if (Array.isArray(value)) {
-      for (let i = 0; i < value.length; i++) mergeValue(value[i] as string)
-    } else {
-      mergeValue(value as string)
-    }
-  }
-
-  // Apply transform dimension values last with the fully accumulated theme
-  for (let i = 0; i < deferredTransforms.length; i++) {
-    merge(finalTheme, deferredTransforms[i]!(finalTheme, appTheme ?? {}, themeModeCallback, config.css))
-  }
-
-  // Ensure pseudo-state keys always exist as objects so .styles() can
-  // destructure without defaults: const { hover, focus, ... } = $rocketstyle
-  // Uses a frozen shared empty object instead of allocating 6 new {} per call.
-  finalTheme.hover ??= EMPTY_PSEUDO
-  finalTheme.focus ??= EMPTY_PSEUDO
-  finalTheme.active ??= EMPTY_PSEUDO
-  finalTheme.disabled ??= EMPTY_PSEUDO
-  finalTheme.pressed ??= EMPTY_PSEUDO
-  finalTheme.readOnly ??= EMPTY_PSEUDO
-
-  return finalTheme
-}
-
-// --------------------------------------------------------
-// resolve theme by mode
-// --------------------------------------------------------
-/**
- * Recursively traverses a theme object and resolves any `themeModeCallback`
- * functions to their concrete light or dark values for the given mode.
- */
-export type GetThemeByMode = (
-  object: Record<string, any>,
-  mode: 'light' | 'dark',
-) => Partial<{
-  baseTheme: Record<string, unknown>
-  themes: Record<string, unknown>
-}>
-
-export const getThemeByMode: GetThemeByMode = (object, mode) => {
-  // Recursive theme walker — `for...in` avoids the per-node
-  // `Object.keys` array allocation that the prior reduce paid. Called
-  // from inside cached `LocalThemeManager` WeakMap tiers (one per
-  // theme/mode transition), so the win is smaller than per-render
-  // helpers but the pattern is consistent. Ported from vitus-labs
-  // `00fdadc2`.
-  const acc: Record<string, any> = {}
-  for (const key in object) {
-    const value = object[key]
-    if (typeof value === 'object' && value !== null) {
-      acc[key] = getThemeByMode(value, mode)
-    } else if (isModeCallback(value)) {
-      acc[key] = value(mode)
-    } else {
-      acc[key] = value
-    }
-  }
-  return acc
-}