@pyreon/attrs 0.24.4 → 0.24.6

package/src/init.ts

@@ -1,65 +0,0 @@
-import { isEmpty } from '@pyreon/ui-core'
-import attrsComponent from './attrs'
-import type { InitAttrsComponent } from './types/InitAttrsComponent'
-import type { ElementType } from './types/utils'
-
-// 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'
-
-/**
- * Public entry point for creating an attrs-enhanced component.
- *
- * ```tsx
- * const Button = attrs({ name: 'Button', component: Element })
- *   .attrs({ tag: 'button' })
- *   .attrs<{ primary?: boolean }>(({ primary }) => ({
- *     backgroundColor: primary ? 'blue' : 'gray',
- *   }))
- * ```
- */
-export type Attrs = <C extends ElementType>({
-  name,
-  component,
-}: {
-  name: string
-  component: C
-}) => ReturnType<InitAttrsComponent<C>>
-
-const attrs: Attrs = ({ name, component }) => {
-  // Validate required params in development — fail fast with clear errors.
-  if (__DEV__) {
-    type Errors = Partial<{
-      component: string
-      name: string
-    }>
-
-    const errors: Errors = {}
-    if (!component) {
-      errors.component = 'Parameter `component` is missing in params!'
-    }
-
-    if (!name) {
-      errors.name = 'Parameter `name` is missing in params!'
-    }
-
-    if (!isEmpty(errors)) {
-      throw Error(JSON.stringify(errors))
-    }
-  }
-
-  // Bootstrap with empty configuration — all chains start from scratch.
-  return attrsComponent({
-    name,
-    component,
-    attrs: [],
-    priorityAttrs: [],
-    filterAttrs: [],
-    compose: {},
-    statics: {},
-  })
-}
-
-export default attrs

package/src/isAttrsComponent.ts

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

package/src/types/AttrsComponent.ts

@@ -1,83 +0,0 @@
-import type { VNode } from '@pyreon/core'
-import type { AttrsCb } from './attrs'
-import type { ConfigAttrs } from './config'
-import type { ComposeParam } from './hoc'
-import type { ElementType, ExtractProps, MergeTypes, TObj } from './utils'
-
-/**
- * Props passed to the inner enhanced component.
- * In Pyreon there's no forwardRef — ref flows as a normal prop.
- */
-export type InnerComponentProps = {
-  'data-attrs'?: string | undefined
-}
-
-/**
- * @param OA   Origin component props params.
- * @param EA   Extended prop types
- * @param S    Defined statics
- * @param HOC  High-order components
- * @param DFP  Calculated final component props
- */
-export interface AttrsComponent<
-  C extends ElementType = ElementType,
-  // original component props
-  OA extends TObj = {},
-  // extended component props
-  EA extends TObj = {},
-  // statics
-  S extends TObj = {},
-  // hocs
-  HOC extends TObj = {},
-  // calculated final props
-  DFP extends Record<string, any> = MergeTypes<[OA, EA]>,
-> {
-  // The component is callable — Pyreon components are plain functions
-  (props: DFP): VNode | null
-
-  // CONFIG chaining method
-  config: <NC extends ElementType | unknown = unknown>({
-    name,
-    component: NC,
-    DEBUG,
-  }: ConfigAttrs<NC>) => NC extends ElementType
-    ? AttrsComponent<NC, ExtractProps<NC>, EA, S, HOC>
-    : AttrsComponent<C, OA, EA, S, HOC>
-
-  // ATTRS chaining method
-  attrs: <P extends TObj | unknown = unknown>(
-    param: P extends TObj ? Partial<DFP & P> | AttrsCb<DFP & P> : Partial<DFP> | AttrsCb<DFP>,
-    config?: Partial<{
-      priority: boolean
-      filter: unknown extends P ? string[] : (keyof (EA & P))[]
-    }>,
-  ) => P extends TObj
-    ? AttrsComponent<C, OA, MergeTypes<[EA, P]>, S, HOC>
-    : AttrsComponent<C, OA, EA, S, HOC>
-
-  // COMPOSE chaining method
-  compose: <P extends ComposeParam>(
-    param: P,
-  ) => P extends TObj
-    ? AttrsComponent<C, OA, EA, S, MergeTypes<[HOC, P]>>
-    : AttrsComponent<C, OA, EA, S, HOC>
-
-  // STATICS chaining method
-  statics: <P extends TObj | unknown = unknown>(
-    param: P,
-  ) => P extends TObj
-    ? AttrsComponent<C, OA, EA, MergeTypes<[S, P]>, HOC>
-    : AttrsComponent<C, OA, EA, S, HOC>
-
-  /** Access to all defined statics on the component. */
-  meta: S
-
-  getDefaultAttrs: (props: TObj) => TObj
-
-  readonly $$originTypes: OA
-  readonly $$extendedTypes: EA
-  readonly $$types: DFP
-
-  IS_ATTRS: true
-  displayName: string
-}

package/src/types/InitAttrsComponent.ts

@@ -1,19 +0,0 @@
-import type { AttrsComponent } from './AttrsComponent'
-import type { Configuration } from './configuration'
-import type { ElementType, ExtractProps } from './utils'
-
-/**
- * Type of the internal `attrsComponent` factory function.
- * Takes a full Configuration and returns an AttrsComponent whose
- * original props (OA) are extracted from the component type C,
- * with all extension slots (EA, S, HOC) starting empty.
- */
-export type InitAttrsComponent<C extends ElementType = ElementType> = (
-  params: Configuration<C>,
-) => AttrsComponent<
-  C,
-  ExtractProps<C>, // OA — original component props
-  {}, // EA — extended props (empty initially)
-  {}, // S  — statics (empty initially)
-  {} //  HOC — composed HOCs (empty initially)
->

package/src/types/attrs.ts

@@ -1,2 +0,0 @@
-/** Callback form of `.attrs()` — receives current props and returns partial overrides. */
-export type AttrsCb<A> = (props: Partial<A>) => Partial<A>

package/src/types/config.ts

@@ -1,13 +0,0 @@
-import type { ElementType } from './utils'
-
-/** A component that has been enhanced by attrs — identified by the `IS_ATTRS` marker. */
-export type AttrsComponentType = ElementType & {
-  IS_ATTRS: true
-}
-
-/** Parameters accepted by the `.config()` chaining method. */
-export type ConfigAttrs<C extends ElementType | unknown> = Partial<{
-  name: string
-  component: C
-  DEBUG: boolean
-}>

package/src/types/configuration.ts

@@ -1,40 +0,0 @@
-import type { ElementType, TFn } from './utils'
-
-export type OptionFunc = (...arg: unknown[]) => Record<string, unknown>
-
-export type InitConfiguration<C> = {
-  name?: string | undefined
-  component: C
-}
-
-/**
- * Internal configuration accumulated across the chaining API.
- * Arrays hold the full chain — each `.attrs()` call appends to these.
- */
-export type Configuration<C = ElementType | unknown> = InitConfiguration<C> & {
-  DEBUG?: boolean | undefined
-  /** Chain of default-props callbacks (resolved in order, later wins). */
-  attrs: OptionFunc[]
-  /** Chain of priority-props callbacks (resolved before `attrs`, can be overridden by both). */
-  priorityAttrs: OptionFunc[]
-  /** Prop names to omit before passing to the underlying component. */
-  filterAttrs: string[]
-  /** Named HOCs — set to null/false to remove from chain. */
-  compose: Record<string, TFn | null | undefined | false>
-  /** Metadata accessible via `Component.meta`. */
-  statics: Record<string, any>
-} & Record<string, any>
-
-/**
- * Single-item variant of Configuration — represents what a single
- * `.attrs()` / `.config()` call contributes (one function, not an array).
- * Used by `cloneAndEnhance` to merge into the accumulated Configuration.
- */
-export type ExtendedConfiguration<C = ElementType | unknown> = InitConfiguration<C> & {
-  DEBUG?: boolean | undefined
-  attrs: OptionFunc
-  priorityAttrs: OptionFunc
-  filterAttrs: string[]
-  compose: Record<string, TFn | null | undefined | false>
-  statics: Record<string, any>
-} & Record<string, any>

package/src/types/hoc.ts

@@ -1,10 +0,0 @@
-import type { ElementType } from './utils'
-
-export type GenericHoc = (component: ElementType) => ElementType
-
-/**
- * Parameters for `.compose()` — a record of named HOCs.
- * Setting a key to `null`, `undefined`, or `false` removes a
- * previously defined HOC from the chain.
- */
-export type ComposeParam = Record<string, GenericHoc | null | undefined | false>

package/src/types/utils.ts

@@ -1,137 +0,0 @@
-import type { VNodeChild } from '@pyreon/core'
-
-// ─── Base Types ───────────────────────────────────────────────
-
-export type TObj = Record<string, unknown>
-export type TFn = (...args: any) => any
-export type CallBackParam = TObj | TFn
-export type DisplayName = string
-
-/**
- * A Pyreon component function that accepts additional static properties.
- * Aligned with @pyreon/core's ComponentFn — returns VNodeChild (not just VNode | null)
- * to support components returning strings, numbers, undefined, etc.
- */
-export type ComponentFn<P = any> = ((props: P) => VNodeChild) & Partial<Record<string, any>>
-
-/**
- * An element type — either a Pyreon component function or an intrinsic tag string.
- */
-export type ElementType<T extends TObj | unknown = any> = ComponentFn<T>
-
-export type ValueOf<T> = T[keyof T]
-
-export type ArrayOfValues<T> = T[keyof T]
-
-export type ArrayOfKeys<T> = keyof T[]
-
-/**
- * A HOC that wraps a component and merges additional props `P`
- * with the wrapped component's own props.
- */
-export type SimpleHoc<P extends Record<string, unknown> = Record<string, unknown>> = <
-  T extends ComponentFn<any>,
->(
-  WrappedComponent: T,
-) => ComponentFn<MergeTypes<[P, ExtractProps<T>]>>
-
-/** Maps each key to `never` if the value is null, undefined, or false. */
-type IsFalseOrNullable<T> = T extends null | undefined | false ? never : true
-export type NullableKeys<T> = { [K in keyof T]: IsFalseOrNullable<T[K]> }
-
-/** Unwraps a callback to its return type, or returns the object as-is. */
-export type ReturnCbParam<P extends TFn | TObj> = P extends TFn ? ReturnType<P> : P
-
-// ─── MergeTypes ───────────────────────────────────────────────
-//
-// Merges a tuple of object types left-to-right (like Object.assign),
-// then strips keys whose values resolved to `never`, `null`, or `undefined`.
-//
-// Usage: MergeTypes<[BaseProps, ExtendedProps, OverrideProps]>
-//
-// This is the backbone of the chaining API — each `.attrs<P>()`
-// call produces MergeTypes<[PreviousProps, P]> so later definitions
-// override earlier ones while preserving the rest.
-// ──────────────────────────────────────────────────────────────
-
-/**
- * Forces TypeScript to expand/flatten a type for better IDE display.
- * Short-circuits for `any` — the mapped type would turn `any` into
- * `{ [x: string]: any; [x: number]: any; [x: symbol]: any }`, losing
- * its identity as `any` and breaking downstream type checks.
- */
-type Id<T> = 0 extends 1 & T ? T : T extends infer U ? { [K in keyof U]: U[K] } : never
-
-/**
- * Strips keys whose values are `never`, `null`, or `undefined`.
- * Uses tuple wrapping `[T[P]] extends [never]` to avoid distribution
- * over union types (a bare `T[P] extends never` would incorrectly
- * match union members).
- *
- * Short-circuits for `any` — the `as` clause in mapped types loses
- * index signatures, which would turn `any` into an empty type.
- */
-type IsAny<T> = 0 extends 1 & T ? true : false
-
-type ExtractNullableKeys<T> = 0 extends 1 & T
-  ? T
-  : {
-      [P in keyof T as IsAny<T[P]> extends true
-        ? P
-        : [T[P]] extends [never]
-          ? never
-          : [T[P]] extends [null | undefined]
-            ? never
-            : P]: T[P]
-    }
-
-/** Merges two types: keeps all keys from L that don't exist in R, then adds all of R. */
-type SpreadTwo<L, R> = Id<Pick<L, Exclude<keyof L, keyof R>> & R>
-
-/** Recursively spreads a tuple of types left-to-right. */
-type Spread<A extends readonly [...any]> = A extends [infer L, ...infer R]
-  ? SpreadTwo<L, Spread<R>>
-  : unknown
-
-/** Recursively checks whether any element in the tuple is `any`. */
-type _HasAny<A> = A extends [infer L, ...infer R] ? (0 extends 1 & L ? true : _HasAny<R>) : false
-
-export type MergeTypes<A extends readonly [...any]> =
-  _HasAny<A> extends true ? any : ExtractNullableKeys<Spread<A>>
-
-// ─── ExtractProps ─────────────────────────────────────────────
-
-/**
- * Extracts the props type from a Pyreon component function — or passes
- * through the input unchanged when it's already a props type.
- *
- * Multi-overload aware: matches up to 4 call signatures and produces the
- * UNION of their first-argument types. Iterator / List / Element are
- * 3-overload primitives — without overload-aware extraction, wrapping
- * them through `attrs()` silently downgraded their public prop surface
- * to the LAST (loosest) overload. Mirrors vitus-labs PR #222.
- *
- * See `@pyreon/rocketstyle` `ExtractProps` for the canonical shape — kept
- * in sync across the 4 copies in core / elements / attrs / rocketstyle.
- */
-export type ExtractProps<TComponentOrTProps> = TComponentOrTProps extends {
-  (props: infer P1, ...args: any): any
-  (props: infer P2, ...args: any): any
-  (props: infer P3, ...args: any): any
-  (props: infer P4, ...args: any): any
-}
-  ? P1 | P2 | P3 | P4
-  : TComponentOrTProps extends {
-        (props: infer P1, ...args: any): any
-        (props: infer P2, ...args: any): any
-        (props: infer P3, ...args: any): any
-      }
-    ? P1 | P2 | P3
-    : TComponentOrTProps extends {
-          (props: infer P1, ...args: any): any
-          (props: infer P2, ...args: any): any
-        }
-      ? P1 | P2
-      : TComponentOrTProps extends ComponentFn<infer TProps>
-        ? TProps
-        : TComponentOrTProps

package/src/utils/attrs.ts

@@ -1,46 +0,0 @@
-import { isEmpty } from '@pyreon/ui-core'
-
-/**
- * Strips keys with `undefined` values from a props object.
- * This prevents undefined consumer props from overriding defaults
- * computed by `.attrs()` callbacks. Only explicitly set values
- * (including `null`) should override defaults.
- */
-type RemoveUndefinedProps = <T extends Record<string, any>>(
-  props: T,
-) => { [I in keyof T as T[I] extends undefined ? never : I]: T[I] }
-
-export const removeUndefinedProps = (<T extends Record<string, any>>(props: T) => {
-  // Direct for-in loop avoids the `Object.keys` array allocation that
-  // the prior `reduce` over `Object.keys(props)` paid on every render.
-  // The hot path fires on every content-equal re-render of any attrs-
-  // wrapped component. Ported from vitus-labs `b003de47`.
-  const result: Record<string, unknown> = {}
-  for (const key in props) {
-    const value = props[key]
-    if (value !== undefined) result[key] = value
-  }
-  return result
-}) as RemoveUndefinedProps
-
-/**
- * Reduces an array of option functions (from chained `.attrs()` calls)
- * into a single merged result. Each function is called with `args`
- * (typically the current props) and its return value is merged
- * left-to-right via Object.assign — so later `.attrs()` calls
- * override earlier ones.
- *
- * Returns a curried function: first call binds the chain, second
- * call provides the arguments and executes the reduction.
- */
-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) => {
-  const result = {}
-  if (!options || isEmpty(options)) return result
-
-  return options.reduce((acc, item) => Object.assign(acc, item(...args)), {})
-}

package/src/utils/chaining.ts

@@ -1,21 +0,0 @@
-type Func = (...args: any) => Record<string, unknown>
-type Obj = Record<string, unknown>
-
-/**
- * Appends a new attrs option to the existing chain of option functions.
- *
- * The `.attrs()` API accepts either an object or a callback. This function
- * normalizes both forms into a function (objects are wrapped in `() => obj`)
- * and appends to the existing array. The array is cloned so each chained
- * component gets its own copy — maintaining immutability across the chain.
- */
-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
-}

package/src/utils/collection.ts

@@ -1,14 +0,0 @@
-/**
- * Filters out keys with `null`, `undefined`, or `false` values.
- * Used to clean compose config — setting a HOC to `false`/`null` removes it.
- */
-type RemoveNullableValues = (obj: Record<string, any>) => Record<string, any>
-export const removeNullableValues: RemoveNullableValues = (obj) => {
-  const result: Record<string, any> = {}
-  for (const [k, v] of Object.entries(obj)) {
-    if (v != null && v !== false) {
-      result[k] = v
-    }
-  }
-  return result
-}

package/src/utils/compose.ts

@@ -1,14 +0,0 @@
-/**
- * Extracts HOC functions from the `.compose()` configuration and reverses
- * them for correct application order. Setting a key to `null`, `undefined`,
- * or `false` removes a previously defined HOC — only actual functions are kept.
- *
- * The reversal is needed because `compose(a, b, c)(Component)` applies as
- * `a(b(c(Component)))`, so the last-defined HOC should wrap innermost.
- */
-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/statics.ts

@@ -1,16 +0,0 @@
-import { isEmpty } from '@pyreon/ui-core'
-
-/**
- * Copies user-defined statics from `.statics()` into the component's
- * `meta` object. These are accessible at `Component.meta.myStatic`.
- */
-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)
-  }
-}