@pyreon/elements 0.14.0 → 0.16.0

package/src/__tests__/wrapper-block-cascade.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, it } from 'vitest'
+import { styles } from '../helpers/Wrapper/styled'
+
+/**
+ * Regression test for the responsive `block` cascade bug (mirrors vitus-labs's
+ * "couple of fixes" PR #121).
+ *
+ * Scenario: a responsive theme like `block: [true, false, true]` runs the
+ * styles callback once per breakpoint with a single-value `t.block`. The bug
+ * was that `align-self`, `flex`/`width` etc. were emitted ONLY when
+ * `t.block` was truthy — so the breakpoint where `t.block` is false emitted
+ * nothing, leaving the previous breakpoint's `align-self: stretch` cascading
+ * through the mobile-first @media query.
+ *
+ * Fix: always emit a value for these properties (truthy → stretch/100%,
+ * falsy → auto/auto). The mobile-first @media cascade then resets cleanly
+ * when `block` flips false at a later breakpoint.
+ *
+ * The styles callback is called per-breakpoint with the per-breakpoint theme
+ * already resolved to a single value — so testing it directly with two
+ * scalar themes is enough to lock in the always-emit contract.
+ */
+
+const identityCss = (strings: TemplateStringsArray, ...vals: unknown[]) => {
+  let r = ''
+  for (let i = 0; i < strings.length; i++) {
+    r += strings[i]
+    if (i < vals.length) {
+      const v = vals[i]
+      // Mirror styled-components / styler interpolation: drop falsy
+      // interpolations, stringify the rest. CSSResult instances (from the
+      // alignContent / extendCss helpers) coerce via their toString.
+      if (v === false || v == null) continue
+      r += String(v)
+    }
+  }
+  return r
+}
+
+const renderAt = (theme: Record<string, unknown>): string =>
+  String(styles({ theme, css: identityCss }))
+
+describe('Wrapper styles — responsive block cascade reset', () => {
+  it('emits stretch/100%/flex when block is true', () => {
+    const out = renderAt({
+      block: true,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    expect(out).toContain('align-self: stretch')
+    expect(out).toContain('width: 100%')
+    expect(out).toContain('display: flex')
+  })
+
+  it('emits auto/auto/inline-flex reset when block is false (key fix)', () => {
+    const out = renderAt({
+      block: false,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    // The fix: these properties MUST be emitted with reset values so the
+    // mobile-first @media cascade doesn't leak `align-self: stretch` from a
+    // smaller breakpoint where block was true.
+    expect(out).toContain('align-self: auto')
+    expect(out).toContain('width: auto')
+    expect(out).toContain('display: inline-flex')
+  })
+
+  it('emits height: 100% when alignY is "block", auto otherwise', () => {
+    const blockY = renderAt({
+      block: false,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'block',
+    })
+    expect(blockY).toContain('height: 100%')
+
+    const nonBlockY = renderAt({
+      block: false,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    expect(nonBlockY).toContain('height: auto')
+  })
+
+  it('does not emit display when childFix is set (parent split)', () => {
+    const out = renderAt({
+      block: true,
+      childFix: true,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    // childFix branch handles its own display rules outside the responsive
+    // styles callback.
+    expect(out).not.toContain('display: flex;')
+    expect(out).not.toContain('display: inline-flex;')
+  })
+
+  it('emits parentFix flex-direction: column only when parentFix is set', () => {
+    const withParentFix = renderAt({
+      block: true,
+      parentFix: true,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    expect(withParentFix).toContain('flex-direction: column')
+
+    const withoutParentFix = renderAt({
+      block: true,
+      direction: 'inline',
+      alignX: 'left',
+      alignY: 'center',
+    })
+    expect(withoutParentFix).not.toContain('flex-direction: column')
+  })
+})

package/src/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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/helpers/Iterator/component.tsx

@@ -10,7 +10,15 @@
 import type { VNode, VNodeChild } from '@pyreon/core'
 import { Fragment } from '@pyreon/core'
 import { isEmpty, render } from '@pyreon/ui-core'
-import type { ExtendedProps, ObjectValue, Props, SimpleValue } from './types'
+import type {
+  ChildrenProps,
+  ExtendedProps,
+  LooseProps,
+  ObjectProps,
+  ObjectValue,
+  SimpleProps,
+  SimpleValue,
+} from './types'
 
 type ClassifiedData =
   | { type: 'simple'; data: SimpleValue[] }
@@ -70,7 +78,7 @@ const attachItemProps: AttachItemProps = ({ i, length }: { i: number; length: nu
   }
 }
 
-const Component = (props: Props) => {
+const Component = (props: LooseProps) => {
   const {
     itemKey,
     valueName,
@@ -246,7 +254,50 @@ const Component = (props: Props) => {
   return renderItems()
 }
 
-export default Object.assign(Component, {
+// ---------------------------------------------------------------------------
+// Public callable type — overloads expose the generic `<T>` API at the JSX
+// boundary while the impl stays loose-typed. TS picks the matching overload
+// based on the props object passed:
+//
+//   <Iterator data={['a','b']} valueName="text" component={Item} />
+//   ^ T inferred as string → SimpleProps<string> overload selected
+//
+//   <Iterator data={users} component={UserCard} />
+//   ^ T inferred as User → ObjectProps<User> overload selected
+//
+//   <Iterator>{...}</Iterator>            → ChildrenProps overload selected
+// ---------------------------------------------------------------------------
+export interface IteratorComponent {
+  // T is inferred from the `data` prop at the JSX site — no explicit
+  // generic argument needed. Order matters: SimpleProps first (matches
+  // `data: SimpleValue[]`), then ObjectProps (object[]), then ChildrenProps,
+  // then a LooseProps fallback.
+  //
+  // The narrow overloads (Simple / Object / Children) drive per-mode T
+  // inference and stricter compile-time errors for direct callers (e.g.
+  // `valueName` required for primitive arrays, forbidden for object arrays).
+  // The LooseProps fallback exists for forwarding patterns where the props
+  // type is a wide union that doesn't bind to any single narrow overload —
+  // notably `Partial<(typeof Wrapper)['$$types']>` spread back into the JSX
+  // site after `@pyreon/rocketstyle`'s 4-overload-aware `ExtractProps`
+  // distributes the union across all of Iterator's call signatures. Without
+  // the loose binding home, the wide union has nowhere to land and TS
+  // reports "no overload matches this call" at every forwarding site.
+  //
+  // Direct callers still see the strict per-mode errors — the loose fallback
+  // only fires when none of the three narrow overloads match.
+  <T extends SimpleValue>(props: SimpleProps<T>): VNodeChild
+  <T extends ObjectValue>(props: ObjectProps<T>): VNodeChild
+  (props: ChildrenProps): VNodeChild
+  (props: LooseProps): VNodeChild
+  isIterator: true
+  RESERVED_PROPS: typeof RESERVED_PROPS
+  displayName?: string
+}
+
+const Iterator = Object.assign(Component, {
   isIterator: true as const,
   RESERVED_PROPS,
-})
+}) as unknown as IteratorComponent
+
+export default Iterator

package/src/helpers/Iterator/index.ts

@@ -1,14 +1,30 @@
 import component from './component'
 import type {
+  ChildrenProps,
   ElementType,
   ExtendedProps,
+  LooseProps,
   MaybeNull,
+  ObjectProps,
   ObjectValue,
   Props,
   PropsCallback,
+  SimpleProps,
   SimpleValue,
 } from './types'
 
-export type { ElementType, ExtendedProps, MaybeNull, ObjectValue, Props, PropsCallback, SimpleValue }
+export type {
+  ChildrenProps,
+  ElementType,
+  ExtendedProps,
+  LooseProps,
+  MaybeNull,
+  ObjectProps,
+  ObjectValue,
+  Props,
+  PropsCallback,
+  SimpleProps,
+  SimpleValue,
+}
 
 export default component

package/src/helpers/Iterator/types.ts

@@ -23,6 +23,80 @@ export type ExtendedProps = {
   position: number
 }
 
+// ---------------------------------------------------------------------------
+// Per-mode prop shapes — narrowed via the `T` data-element type
+// ---------------------------------------------------------------------------
+
+/**
+ * Iterator over an array of strings/numbers. Each item is wrapped in
+ * `{ [valueName]: item }` and that object is what callbacks see + what's
+ * spread onto the rendered component.
+ */
+export type SimpleProps<T extends SimpleValue> = {
+  data: Array<T | MaybeNull>
+  /** A component to be rendered per item. */
+  component: ElementType
+  /**
+   * Key under which each primitive value is exposed to `component` and
+   * callbacks. Defaults to `'children'` at runtime — i.e. the value is
+   * passed to the component as its children.
+   */
+  valueName?: string
+  /** Optional wrapper around each item. */
+  wrapComponent?: ElementType
+  /** Stable key per item (defaults to index). */
+  itemKey?: (item: T, index: number) => SimpleValue
+  /** Extra props merged onto the rendered component, optionally per-item. */
+  itemProps?: TObj | ((item: { [k: string]: T }, ext: ExtendedProps) => TObj)
+  /** Extra props merged onto the wrapper, optionally per-item. */
+  wrapProps?: TObj | ((item: { [k: string]: T }, ext: ExtendedProps) => TObj)
+  children?: never
+}
+
+/**
+ * Iterator over an array of objects. Each item is spread onto the rendered
+ * component as props. Per-item `component` overrides also work — when an
+ * item carries its own `component` field, the wrapper is bypassed.
+ */
+export type ObjectProps<T extends ObjectValue> = {
+  data: Array<T | MaybeNull>
+  /** Default component to be rendered per item (item-level `component` overrides). */
+  component: ElementType
+  /** `valueName` is meaningless when iterating objects — TS forbids it. */
+  valueName?: never
+  /** Optional wrapper around each item. */
+  wrapComponent?: ElementType
+  /** Stable key per item — pick a key from the item, or compute it. */
+  itemKey?: keyof T | ((item: T, index: number) => SimpleValue)
+  /** Extra props merged onto the rendered component, optionally per-item. */
+  itemProps?: TObj | ((item: T, ext: ExtendedProps) => TObj)
+  /** Extra props merged onto the wrapper, optionally per-item. */
+  wrapProps?: TObj | ((item: T, ext: ExtendedProps) => TObj)
+  children?: never
+}
+
+/**
+ * Iterator over `children` — no `data`/`component`. Each child gets
+ * positional metadata via `itemProps` and an optional `wrapComponent`.
+ */
+export type ChildrenProps = {
+  children: VNodeChild
+  data?: never
+  component?: never
+  valueName?: never
+  itemKey?: never
+  wrapComponent?: ElementType
+  itemProps?: TObj | ((_: Record<string, never>, ext: ExtendedProps) => TObj)
+  wrapProps?: TObj | ((_: Record<string, never>, ext: ExtendedProps) => TObj)
+}
+
+// ---------------------------------------------------------------------------
+// Loose backward-compatible fallback shape (today's behavior)
+//
+// Used when callers don't (or can't) parameterize `Props<T>` — keeps the
+// existing call surface intact so this refactor lands non-breaking.
+// ---------------------------------------------------------------------------
+
 export type PropsCallback =
   | TObj
   | ((
@@ -30,50 +104,35 @@ export type PropsCallback =
       extendedProps: ExtendedProps,
     ) => TObj)
 
-export type Props = Partial<{
-  /**
-   * Valid children
-   */
+export type LooseProps = Partial<{
   children: VNodeChild
-
-  /**
-   * Array of data passed to `component` prop
-   */
   data: Array<SimpleValue | ObjectValue | MaybeNull>
-
-  /**
-   * A component to be rendered within list
-   */
   component: ElementType
-
-  /**
-   * Defines name of the prop to be passed to the iteration component
-   * when **data** prop is type of `string[]`, `number[]` or combination
-   * of both. Otherwise ignored.
-   */
   valueName: string
-
-  /**
-   * A component to be rendered within list. `wrapComponent`
-   * wraps `component`. Therefore it can be used to enhance the behavior
-   * of the list component
-   */
   wrapComponent: ElementType
-
-  /**
-   * Extension of **item** `component` props to be passed
-   */
   itemProps: PropsCallback
-
-  /**
-   * Extension of **item** `wrapComponent` props to be passed
-   */
-  wrapProps?: PropsCallback
-
-  /**
-   * Extension of **item** `wrapComponent` props to be passed
-   */
-  itemKey?:
+  wrapProps: PropsCallback
+  itemKey:
     | keyof ObjectValue
     | ((item: SimpleValue | Omit<ObjectValue, 'component'>, index: number) => SimpleValue)
 }>
+
+// ---------------------------------------------------------------------------
+// Public, generic-aware Props<T>
+//
+//   Props<string>          → SimpleProps<string>     (valueName REQUIRED)
+//   Props<{ id; name }>    → ObjectProps<{...}>      (valueName FORBIDDEN)
+//   Props<unknown> / Props → LooseProps              (today's behavior)
+//
+// `unknown extends T` is the canonical "did the caller actually narrow T?"
+// check — true only when T is left as `unknown`, false for any concrete
+// narrowing. Fallback to LooseProps preserves existing call sites.
+// ---------------------------------------------------------------------------
+
+export type Props<T = unknown> = unknown extends T
+  ? LooseProps
+  : T extends SimpleValue
+    ? SimpleProps<T>
+    : T extends ObjectValue
+      ? ObjectProps<T>
+      : ChildrenProps

package/src/helpers/Wrapper/component.tsx

@@ -5,7 +5,9 @@
  * support `display: flex` consistently across browsers.
  */
 import { splitProps } from '@pyreon/core'
+import { getShouldBeEmpty } from '../../Element/utils'
 import { IS_DEVELOPMENT } from '../../utils'
+import { internElementBundle } from '../internElementBundle'
 import Styled from './styled'
 import type { Props } from './types'
 import { isWebFixNeeded } from './utils'
@@ -41,46 +43,81 @@ const Component = (props: Partial<Props> & { ref?: unknown }) => {
 
   const needsFix = !own.dangerouslySetInnerHTML && isWebFixNeeded(own.tag)
 
+  // Void HTML elements (hr, input, img, br, …) cannot have children. Even
+  // a falsy `{own.children}` slot becomes `[undefined]` in the vnode and
+  // trips runtime-dom's void-element warning. Element already skips passing
+  // children to Wrapper for void tags; this guard makes sure the empty
+  // slot is dropped here too instead of leaking into the JSX.
+  const isVoidTag = !own.dangerouslySetInnerHTML && getShouldBeEmpty(own.tag)
+
+  // dangerouslySetInnerHTML and children are mutually exclusive — both
+  // become inner content (per `runtime-server/src/index.ts:228` and
+  // `runtime-dom/src/props.ts:289`). Pre-fix the prop was in OWN_KEYS,
+  // moved into `own` by splitProps, and never re-attached to the rendered
+  // vnode — so `<Logo dangerouslySetInnerHTML={...} />` rendered an empty
+  // <div></div>. Forward the prop to the styled vnode and drop the
+  // children slot when innerHTML is set.
+  const innerHTML = own.dangerouslySetInnerHTML
+
   if (!needsFix) {
+    const bundle = internElementBundle({
+      block: own.block,
+      direction: own.direction,
+      alignX: own.alignX,
+      alignY: own.alignY,
+      equalCols: own.equalCols,
+      extraStyles: own.extendCss,
+    })
+    if (isVoidTag) {
+      return <Styled {...commonProps} $element={bundle} />
+    }
+    if (innerHTML) {
+      return <Styled {...commonProps} $element={bundle} dangerouslySetInnerHTML={innerHTML} />
+    }
     return (
-      <Styled
-        {...commonProps}
-        $element={{
-          block: own.block,
-          direction: own.direction,
-          alignX: own.alignX,
-          alignY: own.alignY,
-          equalCols: own.equalCols,
-          extraStyles: own.extendCss,
-        }}
-      >
+      <Styled {...commonProps} $element={bundle}>
         {own.children}
       </Styled>
     )
   }
 
   const asTag = own.isInline ? 'span' : 'div'
+  const parentBundle = internElementBundle({
+    parentFix: true as const,
+    block: own.block,
+    extraStyles: own.extendCss,
+  })
+  const childBundle = internElementBundle({
+    childFix: true as const,
+    direction: own.direction,
+    alignX: own.alignX,
+    alignY: own.alignY,
+    equalCols: own.equalCols,
+  })
+
+  // needsFix path: innerHTML belongs on the INNER styled node (where the
+  // actual content lives), NOT on the outer flex-fix wrapper. The
+  // `needsFix` computation already excludes the innerHTML case
+  // (`!own.dangerouslySetInnerHTML && isWebFixNeeded(own.tag)`), so this
+  // branch normally won't execute when innerHTML is set — but we keep
+  // the defensive forwarding so the contract is robust against future
+  // refactors of the needsFix gate.
+  if (innerHTML) {
+    return (
+      <Styled {...commonProps} $element={parentBundle}>
+        <Styled
+          as={asTag}
+          $childFix
+          $element={childBundle}
+          dangerouslySetInnerHTML={innerHTML}
+        />
+      </Styled>
+    )
+  }
 
   return (
-    <Styled
-      {...commonProps}
-      $element={{
-        parentFix: true as const,
-        block: own.block,
-        extraStyles: own.extendCss,
-      }}
-    >
-      <Styled
-        as={asTag}
-        $childFix
-        $element={{
-          childFix: true as const,
-          direction: own.direction,
-          alignX: own.alignX,
-          alignY: own.alignY,
-          equalCols: own.equalCols,
-        }}
-      >
+    <Styled {...commonProps} $element={parentBundle}>
+      <Styled as={asTag} $childFix $element={childBundle}>
         {own.children}
       </Styled>
     </Styled>

package/src/helpers/Wrapper/styled.ts

@@ -23,31 +23,25 @@ const parentFixCSS = `
   flex-direction: column;
 `
 
-const fullHeightCSS = `
-  height: 100%;
-`
-
-const blockCSS = `
-  align-self: stretch;
-  flex: 1;
-  min-width: 0;
-`
-
-const childFixPosition = (isBlock?: boolean) => `display: ${isBlock ? 'flex' : 'inline-flex'};`
-
-const styles: ResponsiveStylesCallback = ({ theme: t, css: cssFn }) => cssFn`
-  ${t.alignY === 'block' && fullHeightCSS};
-
+export const styles: ResponsiveStylesCallback = ({ theme: t, css: cssFn }) => cssFn`
   ${alignContent({
     direction: t.direction,
     alignX: t.alignX,
     alignY: t.alignY,
   })};
 
-  ${t.block && blockCSS};
-  ${t.alignY === 'block' && t.block && fullHeightCSS};
+  /*
+   * Always emit a value for the block-related properties so a responsive
+   * theme that flips from \`block: true\` at one breakpoint to \`block: false\`
+   * at another resets cleanly. Previously \`align-self\` / \`width\` / \`height\`
+   * were only set when the truthy branch matched, which left the prior
+   * breakpoint's values cascading through.
+   */
+  ${`align-self: ${t.block ? 'stretch' : 'auto'};
+     width: ${t.block ? '100%' : 'auto'};
+     height: ${t.alignY === 'block' ? '100%' : 'auto'};`};
 
-  ${!t.childFix && childFixPosition(t.block)};
+  ${!t.childFix && `display: ${t.block ? 'flex' : 'inline-flex'};`};
   ${t.parentFix && parentFixCSS};
 
   ${t.extraStyles && extendCss(t.extraStyles as Parameters<typeof extendCss>[0])};

package/src/helpers/internElementBundle.ts

@@ -0,0 +1,37 @@
+/**
+ * Module-scope intern cache for `$element` bundles passed to Wrapper's styled
+ * component. Same primitive prop tuple → same object identity, so the styler's
+ * `elClassCache` (added 2026-Q2 alongside this) hits and skips the resolve
+ * pipeline. Analogous to `@pyreon/rocketstyle`'s dimension-prop memo (PR #344)
+ * but at the layer below — covers non-rocketstyle Element / Wrapper / Text usage
+ * AND the residual styled wrappers under any rocketstyle component.
+ *
+ * Cache key is a JSON-stringified shallow snapshot of the bundle. LRU-bound at
+ * 256 entries; oldest-first eviction. Bail (return the input as-is, no cache)
+ * when any value is a function (signal accessor) or a non-string object (CSS
+ * callback / CSSResult / nested object) — those cannot be safely round-tripped
+ * through JSON without losing identity guarantees.
+ */
+const _bundleCache = new Map<string, Record<string, unknown>>()
+const BUNDLE_CAP = 256
+
+export const internElementBundle = <T extends Record<string, unknown>>(bundle: T): T => {
+  for (const k in bundle) {
+    const v = bundle[k]
+    if (typeof v === 'function') return bundle
+    if (v != null && typeof v === 'object') return bundle
+  }
+  const key = JSON.stringify(bundle)
+  const existing = _bundleCache.get(key)
+  if (existing) {
+    _bundleCache.delete(key)
+    _bundleCache.set(key, existing)
+    return existing as T
+  }
+  if (_bundleCache.size >= BUNDLE_CAP) {
+    const oldest = _bundleCache.keys().next().value
+    if (oldest !== undefined) _bundleCache.delete(oldest)
+  }
+  _bundleCache.set(key, bundle)
+  return bundle
+}

package/src/index.ts

@@ -3,12 +3,16 @@ import { Provider } from '@pyreon/unistyle'
 export type { ElementProps, PyreonElement } from './Element'
 export { Element } from './Element'
 export type {
+  ChildrenProps as IteratorChildrenProps,
   ElementType,
   ExtendedProps,
+  LooseProps as IteratorLooseProps,
   MaybeNull,
+  ObjectProps as IteratorObjectProps,
   ObjectValue,
   Props as IteratorProps,
   PropsCallback,
+  SimpleProps as IteratorSimpleProps,
   SimpleValue,
 } from './helpers/Iterator'
 export { default as Iterator } from './helpers/Iterator'

package/src/types.ts

@@ -69,8 +69,39 @@ export type Responsive =
 
 export type ExtendCss = Css | Css[] | Partial<Record<BreakpointKeys, Css>>
 
-export type ExtractProps<TComponentOrTProps> =
-  TComponentOrTProps extends ComponentFn<infer TProps> ? TProps : TComponentOrTProps
+/**
+ * Extracts the props type from a Pyreon component function — multi-overload
+ * aware. Matches up to 4 call signatures and produces the UNION of their
+ * first-argument types. Iterator / List ship 3-overload primitives whose
+ * LAST overload is `ChildrenProps` (the loosest); without overload-aware
+ * extraction, `ExtractProps<Iterator>` returned just `ChildrenProps` and
+ * lost `SimpleProps<T>` / `ObjectProps<T>` shapes. Mirrors vitus-labs
+ * PR #222.
+ *
+ * Kept in sync with the copies in `@pyreon/core` / `@pyreon/attrs` /
+ * `@pyreon/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
 
 export type PyreonComponent<P extends Record<string, any> = {}> = ComponentFn<P> & PyreonStatic
 

package/src/utils.ts

@@ -2,7 +2,4 @@
 // literal-replaced so prod bundles tree-shake the dev branch to zero bytes.
 // Typed through a narrowing interface so downstream packages don't need
 // `vite/client` in their tsconfigs to type-check this file transitively.
-interface ViteMeta {
-  readonly env?: { readonly DEV?: boolean }
-}
-export const IS_DEVELOPMENT: boolean = (import.meta as ViteMeta).env?.DEV === true
+export const IS_DEVELOPMENT: boolean = process.env.NODE_ENV !== 'production'

package/lib/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index2.d.ts","names":[],"sources":["../../src/types.ts","../../src/Element/types.ts","../../src/Element/component.tsx","../../src/helpers/Iterator/types.ts","../../src/helpers/Iterator/component.tsx","../../src/List/component.tsx","../../src/Overlay/context.tsx","../../src/Overlay/positioning.ts","../../src/Overlay/useOverlay.tsx","../../src/Overlay/component.tsx","../../src/Portal/component.tsx","../../src/Text/component.tsx","../../src/Util/component.tsx"],"mappings":"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"}