@pyreon/attrs 0.24.5 → 0.24.6

package/src/__tests__/attrsHoc.test.ts

@@ -1,179 +0,0 @@
-import { h } from '@pyreon/core'
-import createAttrsHOC from '../hoc/attrsHoc'
-
-const Receiver = (props: any) => ({
-  type: 'div',
-  props: { ...props, 'data-testid': 'receiver' },
-  children: props.label ?? '',
-  key: null,
-})
-
-// --------------------------------------------------------
-// attrsHoc - props merging
-// --------------------------------------------------------
-describe('attrsHoc - props merging', () => {
-  it('should pass through props unchanged when no attrs defined', () => {
-    const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({ label: 'hello', 'data-custom': 'yes' }) as any
-    expect(result.children).toBe('hello')
-    expect(result.props['data-custom']).toBe('yes')
-  })
-
-  it('should apply attrs as default props', () => {
-    const hoc = createAttrsHOC({
-      attrs: [(_props: any) => ({ label: 'default' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({}) as any
-    expect(result.children).toBe('default')
-  })
-
-  it('should let explicit props override attrs', () => {
-    const hoc = createAttrsHOC({
-      attrs: [() => ({ label: 'from-attrs' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({ label: 'explicit' }) as any
-    expect(result.children).toBe('explicit')
-  })
-
-  it('should apply priorityAttrs with lowest precedence', () => {
-    const hoc = createAttrsHOC({
-      attrs: [(_props: any) => ({ label: 'from-attrs' })],
-      priorityAttrs: [(_props: any) => ({ label: 'from-priority' })],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({}) as any
-    expect(result.children).toBe('from-attrs')
-  })
-
-  it('should merge results from multiple attrs functions', () => {
-    const hoc = createAttrsHOC({
-      attrs: [() => ({ 'data-first': 'a' }), () => ({ 'data-second': 'b' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({}) as any
-    expect(result.props['data-first']).toBe('a')
-    expect(result.props['data-second']).toBe('b')
-  })
-
-  it('should remove undefined props so they dont override defaults', () => {
-    const hoc = createAttrsHOC({
-      attrs: [() => ({ label: 'default-label' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({ label: undefined }) as any
-    expect(result.children).toBe('default-label')
-  })
-
-  it('should allow null to override defaults', () => {
-    const hoc = createAttrsHOC({
-      attrs: [() => ({ label: 'default-label' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    const result = Enhanced({ label: null }) as any
-    expect(result.children).toBe('')
-  })
-})
-
-// --------------------------------------------------------
-// attrsHoc - attrs callback receives props
-// --------------------------------------------------------
-describe('attrsHoc - attrs callback receives props', () => {
-  it('should pass filtered props to attrs callback', () => {
-    const attrsFn = vi.fn(() => ({}))
-    const hoc = createAttrsHOC({
-      attrs: [attrsFn],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(Receiver)
-
-    Enhanced({ variant: 'primary', size: 'lg' })
-    expect(attrsFn).toHaveBeenCalledWith(
-      expect.objectContaining({ variant: 'primary', size: 'lg' }),
-    )
-  })
-
-  it('should pass priority attrs merged with props to attrs callback', () => {
-    const attrsFn = vi.fn(() => ({}))
-    const hoc = createAttrsHOC({
-      attrs: [attrsFn],
-      priorityAttrs: [() => ({ fromPriority: true })],
-    })
-    const Enhanced = hoc(Receiver)
-
-    Enhanced({ variant: 'primary' })
-    expect(attrsFn).toHaveBeenCalledWith(
-      expect.objectContaining({ variant: 'primary', fromPriority: true }),
-    )
-  })
-})
-
-// --------------------------------------------------------
-// attrsHoc - ref passthrough
-// --------------------------------------------------------
-describe('attrsHoc - ref passthrough', () => {
-  it('should pass ref as a normal prop to wrapped component', () => {
-    const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
-    const Enhanced = hoc(Receiver)
-
-    const refObj = { current: null }
-    const result = Enhanced({ ref: refObj }) as any
-    expect(result.props.ref).toBe(refObj)
-  })
-})
-
-// ─── attrsHoc — real h() round-trip (parallel to the Receiver mock) ──
-//
-// The Receiver above is a mock that returns a `{ type, props,
-// children, key }` literal. The tests assert against that shape.
-// This block re-runs the core HOC contracts against a Receiver that
-// builds its return value via real `h()` from `@pyreon/core` —
-// catches divergence between the mock shape and the actual VNode
-// shape h() produces.
-
-describe('attrsHoc — real h() round-trip', () => {
-  // Receiver that returns a real VNode via h() instead of a literal.
-  const ReceiverH = (props: any) =>
-    h('div', { ...props, 'data-testid': 'receiver' }, props.label ?? '')
-
-  it('passes through props unchanged when no attrs defined', () => {
-    const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
-    const Enhanced = hoc(ReceiverH as any)
-    const result = Enhanced({ label: 'hello', 'data-custom': 'yes' }) as any
-    expect(result.props.label).toBe('hello')
-    expect(result.props['data-custom']).toBe('yes')
-    expect(result.type).toBe('div')
-  })
-
-  it('applies attrs as default props through real h()', () => {
-    const hoc = createAttrsHOC({
-      attrs: [(_props: any) => ({ label: 'default' })],
-      priorityAttrs: [],
-    })
-    const Enhanced = hoc(ReceiverH as any)
-    const result = Enhanced({}) as any
-    expect(result.props.label).toBe('default')
-  })
-
-  it('passes ref through real h() output unchanged', () => {
-    const hoc = createAttrsHOC({ attrs: [], priorityAttrs: [] })
-    const Enhanced = hoc(ReceiverH as any)
-    const refObj = { current: null }
-    const result = Enhanced({ ref: refObj }) as any
-    expect(result.props.ref).toBe(refObj)
-  })
-})

package/src/__tests__/utils.test.ts

@@ -1,241 +0,0 @@
-import { calculateChainOptions, removeUndefinedProps } from '../utils/attrs'
-import { chainOptions } from '../utils/chaining'
-import { removeNullableValues } from '../utils/collection'
-import { calculateHocsFuncs } from '../utils/compose'
-import { createStaticsEnhancers } from '../utils/statics'
-
-// --------------------------------------------------------
-// removeUndefinedProps
-// --------------------------------------------------------
-describe('removeUndefinedProps', () => {
-  it('should remove properties with undefined values', () => {
-    const result = removeUndefinedProps({
-      a: 1,
-      b: undefined,
-      c: 'hello',
-    })
-    expect(result).toEqual({ a: 1, c: 'hello' })
-  })
-
-  it('should keep null values', () => {
-    const result = removeUndefinedProps({ a: null, b: undefined })
-    expect(result).toEqual({ a: null })
-  })
-
-  it('should keep false values', () => {
-    const result = removeUndefinedProps({ a: false, b: undefined })
-    expect(result).toEqual({ a: false })
-  })
-
-  it('should keep zero values', () => {
-    const result = removeUndefinedProps({ a: 0, b: undefined })
-    expect(result).toEqual({ a: 0 })
-  })
-
-  it('should keep empty string values', () => {
-    const result = removeUndefinedProps({ a: '', b: undefined })
-    expect(result).toEqual({ a: '' })
-  })
-
-  it('should return empty object when all values are undefined', () => {
-    const result = removeUndefinedProps({ a: undefined, b: undefined })
-    expect(result).toEqual({})
-  })
-
-  it('should return all props when none are undefined', () => {
-    const input = { a: 1, b: 'test', c: true }
-    const result = removeUndefinedProps(input)
-    expect(result).toEqual(input)
-  })
-
-  it('should handle empty object', () => {
-    const result = removeUndefinedProps({})
-    expect(result).toEqual({})
-  })
-})
-
-// --------------------------------------------------------
-// removeNullableValues
-// --------------------------------------------------------
-describe('removeNullableValues', () => {
-  it('should remove null values', () => {
-    const result = removeNullableValues({ a: 1, b: null })
-    expect(result).toEqual({ a: 1 })
-  })
-
-  it('should remove undefined values', () => {
-    const result = removeNullableValues({ a: 1, b: undefined })
-    expect(result).toEqual({ a: 1 })
-  })
-
-  it('should remove false values', () => {
-    const result = removeNullableValues({ a: 1, b: false })
-    expect(result).toEqual({ a: 1 })
-  })
-
-  it('should keep zero values', () => {
-    const result = removeNullableValues({ a: 0, b: null })
-    expect(result).toEqual({ a: 0 })
-  })
-
-  it('should keep empty string values', () => {
-    const result = removeNullableValues({ a: '', b: null })
-    expect(result).toEqual({ a: '' })
-  })
-
-  it('should keep truthy values', () => {
-    const result = removeNullableValues({ a: 1, b: 'test', c: true })
-    expect(result).toEqual({ a: 1, b: 'test', c: true })
-  })
-
-  it('should handle empty object', () => {
-    const result = removeNullableValues({})
-    expect(result).toEqual({})
-  })
-})
-
-// --------------------------------------------------------
-// calculateChainOptions
-// --------------------------------------------------------
-describe('calculateChainOptions', () => {
-  it('should return empty object when no options provided', () => {
-    const calculate = calculateChainOptions(undefined)
-    const result = calculate([{}])
-    expect(result).toEqual({})
-  })
-
-  it('should return empty object for empty options array', () => {
-    const calculate = calculateChainOptions([])
-    const result = calculate([{}])
-    expect(result).toEqual({})
-  })
-
-  it('should execute a single option function', () => {
-    const fn = (props: any) => ({
-      color: props.variant === 'primary' ? 'blue' : 'gray',
-    })
-    const calculate = calculateChainOptions([fn])
-    const result = calculate([{ variant: 'primary' }])
-    expect(result).toEqual({ color: 'blue' })
-  })
-
-  it('should merge results from multiple option functions', () => {
-    const fn1 = (_: any) => ({ color: 'blue' })
-    const fn2 = (_: any) => ({ size: 'large' })
-    const calculate = calculateChainOptions([fn1, fn2])
-    const result = calculate([{}])
-    expect(result).toEqual({ color: 'blue', size: 'large' })
-  })
-
-  it('should let later functions override earlier ones', () => {
-    const fn1 = (_: any) => ({ color: 'blue' })
-    const fn2 = (_: any) => ({ color: 'red' })
-    const calculate = calculateChainOptions([fn1, fn2])
-    const result = calculate([{}])
-    expect(result).toEqual({ color: 'red' })
-  })
-
-  it('should pass arguments to each option function', () => {
-    const fn = vi.fn((_: any) => ({}))
-    const calculate = calculateChainOptions([fn])
-    const props = { variant: 'primary' }
-    calculate([props])
-    expect(fn).toHaveBeenCalledWith(props)
-  })
-})
-
-// --------------------------------------------------------
-// chainOptions
-// --------------------------------------------------------
-describe('chainOptions', () => {
-  it('should return default options when opts is undefined', () => {
-    const defaults = [() => ({})]
-    const result = chainOptions(undefined, defaults)
-    expect(result).toEqual(defaults)
-  })
-
-  it('should append function to defaults', () => {
-    const fn1 = () => ({ a: 1 })
-    const fn2 = () => ({ b: 2 })
-    const result = chainOptions(fn2, [fn1])
-    expect(result).toHaveLength(2)
-    expect(result[0]).toBe(fn1)
-    expect(result[1]).toBe(fn2)
-  })
-
-  it('should wrap object in a function and append', () => {
-    const obj = { color: 'blue' }
-    const result = chainOptions(obj, [])
-    expect(result).toHaveLength(1)
-    expect(result[0]?.()).toEqual(obj)
-  })
-
-  it('should return empty array when no defaults and undefined opts', () => {
-    const result = chainOptions(undefined, [])
-    expect(result).toEqual([])
-  })
-
-  it('should not mutate the defaults array', () => {
-    const defaults = [() => ({})]
-    const fn = () => ({ a: 1 })
-    const result = chainOptions(fn, defaults)
-    expect(defaults).toHaveLength(1)
-    expect(result).toHaveLength(2)
-  })
-})
-
-// --------------------------------------------------------
-// createStaticsEnhancers
-// --------------------------------------------------------
-describe('createStaticsEnhancers', () => {
-  it('should assign options to context', () => {
-    const context: Record<string, any> = {}
-    createStaticsEnhancers({
-      context,
-      options: { theme: 'dark', variant: 'primary' },
-    })
-    expect(context).toEqual({ theme: 'dark', variant: 'primary' })
-  })
-
-  it('should not modify context when options is empty', () => {
-    const context: Record<string, any> = { existing: true }
-    createStaticsEnhancers({ context, options: {} })
-    expect(context).toEqual({ existing: true })
-  })
-
-  it('should merge with existing context properties', () => {
-    const context: Record<string, any> = { existing: true }
-    createStaticsEnhancers({ context, options: { newProp: 'value' } })
-    expect(context).toEqual({ existing: true, newProp: 'value' })
-  })
-})
-
-// --------------------------------------------------------
-// calculateHocsFuncs
-// --------------------------------------------------------
-describe('calculateHocsFuncs', () => {
-  it('should return empty array for empty options', () => {
-    const result = calculateHocsFuncs({})
-    expect(result).toEqual([])
-  })
-
-  it('should filter out non-function values', () => {
-    const fn = (x: any) => x
-    const result = calculateHocsFuncs({ a: fn, b: 'string', c: 123 })
-    expect(result).toHaveLength(1)
-    expect(result[0]).toBe(fn)
-  })
-
-  it('should reverse the order of functions', () => {
-    const fn1 = (x: any) => x
-    const fn2 = (x: any) => x
-    const result = calculateHocsFuncs({ a: fn1, b: fn2 })
-    expect(result[0]).toBe(fn2)
-    expect(result[1]).toBe(fn1)
-  })
-
-  it('should return empty array for undefined input', () => {
-    const result = calculateHocsFuncs(undefined as any)
-    expect(result).toEqual([])
-  })
-})

package/src/attrs.ts

@@ -1,131 +0,0 @@
-import { compose, hoistNonReactStatics, omit, pick } from '@pyreon/ui-core'
-import { attrsHoc } from './hoc'
-import type { AttrsComponent as AttrsComponentType } from './types/AttrsComponent'
-import type { Configuration, ExtendedConfiguration } from './types/configuration'
-import type { InitAttrsComponent } from './types/InitAttrsComponent'
-import { calculateChainOptions } from './utils/attrs'
-import { chainOptions } from './utils/chaining'
-import { calculateHocsFuncs } from './utils/compose'
-import { createStaticsEnhancers } from './utils/statics'
-
-// Dev-mode gate. `import.meta.env.DEV` is literal-replaced by Vite at build
-// time and tree-shakes to zero bytes in prod. The previous
-// `process.env.NODE_ENV !== 'production'` form was dead code in real Vite
-// browser bundles (Vite does not polyfill `process`).
-const __DEV__ = process.env.NODE_ENV !== 'production'
-
-/**
- * Clones the current configuration and merges new options, then creates a
- * fresh component. This makes the chaining API immutable — each `.attrs()`
- * / `.config()` / `.statics()` call returns a brand-new component with an
- * updated configuration rather than mutating the existing one.
- */
-type CloneAndEnhance = (
-  defaultOpts: Configuration,
-  opts: Partial<ExtendedConfiguration>,
-) => ReturnType<typeof attrsComponent>
-
-const cloneAndEnhance: CloneAndEnhance = (defaultOpts, opts) =>
-  attrsComponent({
-    ...defaultOpts,
-    ...(opts.name ? { name: opts.name } : undefined),
-    ...(opts.component ? { component: opts.component } : undefined),
-    attrs: chainOptions(opts.attrs, defaultOpts.attrs),
-    filterAttrs: [...(defaultOpts.filterAttrs ?? []), ...(opts.filterAttrs ?? [])],
-    priorityAttrs: chainOptions(opts.priorityAttrs, defaultOpts.priorityAttrs),
-    statics: { ...defaultOpts.statics, ...opts.statics },
-    compose: { ...defaultOpts.compose, ...opts.compose },
-  } as Parameters<typeof attrsComponent>[0])
-
-/**
- * Core factory that builds an attrs-enhanced Pyreon component.
- *
- * Creates a plain ComponentFn that:
- * 1. Wraps the original with attrsHoc (default props) + user HOCs from `.compose()`.
- * 2. Filters out internal props listed in `filterAttrs`.
- * 3. Attaches `data-attrs` attribute in development for debugging.
- *
- * Then adds chaining methods (`.attrs()`, `.config()`, `.compose()`, `.statics()`)
- * as static properties — each calls `cloneAndEnhance` to produce a new component.
- *
- * In Pyreon, there is no forwardRef — ref flows as a normal prop.
- * Components are plain functions that run once per mount.
- */
-const attrsComponent: InitAttrsComponent = (options) => {
-  const componentName = options.name ?? options.component.displayName ?? options.component.name
-
-  const RenderComponent = options.component
-
-  // Build the HOC chain: attrsHoc is always first (resolves default props),
-  // followed by user-composed HOCs in reverse order (outermost wraps first).
-  const hocsFuncs = [attrsHoc(options), ...calculateHocsFuncs(options.compose)]
-
-  // The inner component receives already-computed props from the HOC chain.
-  // It handles prop filtering and final rendering.
-  const EnhancedComponent = (props: Record<string, any>) => {
-    const needsFiltering = options.filterAttrs && options.filterAttrs.length > 0
-
-    const filteredProps = needsFiltering ? omit(props, options.filterAttrs) : props
-
-    const finalProps = __DEV__
-      ? { ...filteredProps, 'data-attrs': componentName }
-      : filteredProps
-
-    return RenderComponent(finalProps)
-  }
-
-  // Apply the full HOC chain: compose(attrsHoc, ...userHocs)(EnhancedComponent)
-  const AttrsComponent: AttrsComponentType = compose(...hocsFuncs)(EnhancedComponent)
-
-  AttrsComponent.IS_ATTRS = true
-  AttrsComponent.displayName = componentName
-  AttrsComponent.meta = {}
-
-  // Copy static properties from the original component.
-  hoistNonReactStatics(AttrsComponent, options.component)
-
-  // Populate `component.meta` with user-defined statics from `.statics()`.
-  createStaticsEnhancers({
-    context: AttrsComponent.meta,
-    options: options.statics,
-  })
-
-  // ─── Chaining Methods ──────────────────────────────────
-  // Each method creates a new component via cloneAndEnhance.
-  // The original component is never mutated.
-  Object.assign(AttrsComponent, {
-    attrs: (attrs: any, { priority, filter }: any = {}) => {
-      const result: Record<string, any> = {}
-
-      if (filter) {
-        result.filterAttrs = filter
-      }
-
-      if (priority) {
-        result.priorityAttrs = attrs as ExtendedConfiguration['priorityAttrs']
-
-        return cloneAndEnhance(options, result)
-      }
-
-      result.attrs = attrs as ExtendedConfiguration['attrs']
-
-      return cloneAndEnhance(options, result)
-    },
-
-    config: (opts: any = {}) => {
-      const result = pick(opts)
-
-      return cloneAndEnhance(options, result)
-    },
-
-    compose: (opts: any) => cloneAndEnhance(options, { compose: opts }),
-
-    statics: (opts: any) => cloneAndEnhance(options, { statics: opts }),
-
-    getDefaultAttrs: (props: any) => calculateChainOptions(options.attrs)([props]),
-  })
-
-  return AttrsComponent
-}
-
-export default attrsComponent

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/attrsHoc.ts

@@ -1,74 +0,0 @@
-import type { Configuration } from '../types/configuration'
-import type { ComponentFn } from '../types/utils'
-import { calculateChainOptions, removeUndefinedProps } from '../utils/attrs'
-
-export type AttrsStyleHOC = ({
-  attrs,
-  priorityAttrs,
-}: Pick<Configuration, 'attrs' | 'priorityAttrs'>) => (
-  WrappedComponent: ComponentFn<any>,
-) => ComponentFn<any>
-
-/**
- * Creates the core HOC that computes default props from the `.attrs()` chain.
- *
- * This is always the outermost HOC in the compose chain, so it runs first.
- * It resolves both priority and normal attrs callbacks, then merges them
- * with the consumer's explicit props following this precedence:
- *
- *   priorityAttrs < normalAttrs < explicit props  (last wins)
- *
- * In Pyreon, components are plain functions — no forwardRef needed.
- * The ref flows as a normal prop through the chain.
- */
-const createAttrsHOC: AttrsStyleHOC = ({ attrs, priorityAttrs }) => {
-  // Pre-build the chain reducers once (not per render).
-  const calculateAttrs = calculateChainOptions(attrs)
-  const calculatePriorityAttrs = calculateChainOptions(priorityAttrs)
-  // Most components never call .attrs() — short-circuit the merge work below
-  // so the no-chain mount path skips 2 reducer invocations + 3 object spreads.
-  // Mirrors vitus-labs's attrsHoc fast-path; React-side memoization
-  // (useMemo / useStableValue) is omitted because Pyreon components run once
-  // per mount, not on every render.
-  const hasAttrs = (attrs?.length ?? 0) > 0
-  const hasPriorityAttrs = (priorityAttrs?.length ?? 0) > 0
-  const hasAnyChain = hasAttrs || hasPriorityAttrs
-
-  const attrsHoc = (WrappedComponent: ComponentFn<any>) => {
-    const HOCComponent: ComponentFn<any> = (props) => {
-      // Strip undefined values so they don't shadow defaults from attrs callbacks.
-      const filteredProps = removeUndefinedProps(props)
-
-      // Fast path: no attrs configured — skip reducers + spreads entirely.
-      if (!hasAnyChain) return WrappedComponent(filteredProps)
-
-      // 1. Resolve priority attrs (lowest precedence defaults).
-      const prioritizedAttrs = hasPriorityAttrs
-        ? calculatePriorityAttrs([filteredProps])
-        : null
-      // 2. Resolve normal attrs — these see priority + explicit props as input.
-      const finalAttrs = hasAttrs
-        ? calculateAttrs([
-            prioritizedAttrs
-              ? { ...prioritizedAttrs, ...filteredProps }
-              : filteredProps,
-          ])
-        : null
-
-      // 3. Merge: priority < normal attrs < explicit props (last wins).
-      const finalProps = {
-        ...prioritizedAttrs,
-        ...finalAttrs,
-        ...filteredProps,
-      }
-
-      return WrappedComponent(finalProps)
-    }
-
-    return HOCComponent
-  }
-
-  return attrsHoc
-}
-
-export default createAttrsHOC

package/src/hoc/index.ts

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

package/src/index.ts

@@ -1,26 +0,0 @@
-import type { Attrs } from './init'
-import attrs from './init'
-import type { IsAttrsComponent } from './isAttrsComponent'
-import isAttrsComponent from './isAttrsComponent'
-import type { AttrsComponent } from './types/AttrsComponent'
-import type { AttrsCb } from './types/attrs'
-import type { AttrsComponentType, ConfigAttrs } from './types/config'
-import type { ComposeParam, GenericHoc } from './types/hoc'
-import type { ComponentFn, ElementType, TObj } from './types/utils'
-
-export type {
-  Attrs,
-  AttrsCb,
-  AttrsComponent,
-  AttrsComponentType,
-  ComponentFn,
-  ComposeParam,
-  ConfigAttrs,
-  ElementType,
-  GenericHoc,
-  IsAttrsComponent,
-  TObj,
-}
-
-export { attrs, isAttrsComponent }
-export default attrs