@pyreon/solid-compat 0.13.1 → 0.15.0

package/src/jsx-runtime.ts

@@ -32,6 +32,7 @@ import {
   For,
   Fragment,
   h,
+  isNativeCompat,
   Match,
   onUnmount,
   Show,
@@ -269,11 +270,24 @@ export function jsx(
   const propsWithKey = (key != null ? { ...rest, key } : rest) as Props
 
   if (typeof type === 'function') {
+    // Defense-in-depth: hardcoded set of Pyreon core control-flow primitives
+    // that are always native (kept even after the marker convergence — these
+    // are imported into solid-compat directly, so guarding their identity
+    // doesn't cost a property lookup and ensures the marker is never lost
+    // through any tree-shaking edge case).
     if (_nativeComponents.has(type)) {
       const componentProps = children !== undefined ? { ...propsWithKey, children } : propsWithKey
       return h(type as ComponentFn, componentProps)
     }
 
+    // Native Pyreon framework components (context Providers, RouterView, etc.)
+    // skip compat wrapping — see `@pyreon/core`'s `nativeCompat()` for the
+    // full contract.
+    if (isNativeCompat(type)) {
+      const componentProps = children !== undefined ? { ...propsWithKey, children } : propsWithKey
+      return h(type as ComponentFn, componentProps)
+    }
+
     const wrapped = wrapCompatComponent(type)
     const componentProps =
       children !== undefined ? { ...propsWithKey, children } : { ...propsWithKey }

package/src/solid-compat.browser.test.ts

@@ -0,0 +1,32 @@
+import { h } from '@pyreon/core'
+import { describe, expect, it } from 'vitest'
+import { mountInBrowser } from '@pyreon/test-utils/browser'
+import { createSignal } from './index'
+
+/**
+ * Real-browser smoke test for `@pyreon/solid-compat`.
+ *
+ * Per the test-environment-parity rule (`pyreon/require-browser-smoke-test`),
+ * every browser-categorized package must ship at least one
+ * `*.browser.test.*` file. This catches regressions that happy-dom unit
+ * tests can hide: importing the public API and exercising the SolidJS
+ * `createSignal` shim end-to-end in real Chromium.
+ */
+describe('@pyreon/solid-compat — browser smoke', () => {
+  it('createSignal returns [getter, setter] that round-trip', () => {
+    const [count, setCount] = createSignal(0)
+    expect(count()).toBe(0)
+    setCount(7)
+    expect(count()).toBe(7)
+  })
+
+  it('mounts a static element in real browser', () => {
+    const [name] = createSignal('solid-compat')
+    const vnode = h('div', { id: 'solid-compat' }, name())
+    const { container, unmount } = mountInBrowser(vnode)
+    const el = container.querySelector('#solid-compat')!
+    expect(el.textContent).toBe('solid-compat')
+    unmount()
+    expect(document.getElementById('solid-compat')).toBeNull()
+  })
+})

package/src/tests/native-marker-bypass.test.tsx

@@ -0,0 +1,70 @@
+import type { ComponentFn } from '@pyreon/core'
+import { createContext, h, nativeCompat, provide, useContext } from '@pyreon/core'
+import { mount } from '@pyreon/runtime-dom'
+import { describe, expect, it } from 'vitest'
+import { jsx } from '../jsx-runtime'
+
+// Per-compat unit-level regression test for the marker-bypass contract.
+// See `react-compat/src/tests/native-marker-bypass.test.tsx` for the full
+// rationale + bisect-verification notes.
+//
+// Solid-compat note: solid-compat's jsx() has TWO native-routing paths in
+// sequence — first the hardcoded `_nativeComponents` Set as defense-in-depth
+// (Show, For, Switch, Match, Suspense, ErrorBoundary), then the marker
+// check. These tests use USER-defined NativeProvider/Consumer (NOT in the
+// hardcoded set), so the bypass MUST come from the marker path
+// (`isNativeCompat(type)`), proving the marker check fires correctly.
+//
+// Bisect-verified per file: removing the `if (isNativeCompat(type))` branch
+// from solid-compat's jsx-runtime (while keeping the `_nativeComponents`
+// set check) causes test #1 to fail with
+// `expected [Function wrapped] to be [Function Native]`.
+
+function container(): HTMLElement {
+  const el = document.createElement('div')
+  document.body.appendChild(el)
+  return el
+}
+
+describe('solid-compat — nativeCompat() marker bypass', () => {
+  it('jsx() routes marked components through h() directly (no wrapper)', () => {
+    const Native = (props: { children?: unknown }) => h('div', null, props.children as never)
+    nativeCompat(Native)
+
+    const vnode = jsx(Native, {})
+
+    expect(vnode.type).toBe(Native)
+  })
+
+  it('jsx() wraps UNMARKED components (control — bypass is selective)', () => {
+    const Unmarked = (props: { children?: unknown }) => h('div', null, props.children as never)
+
+    const vnode = jsx(Unmarked, {})
+
+    expect(vnode.type).not.toBe(Unmarked)
+    expect(typeof vnode.type).toBe('function')
+  })
+
+  it('marked Provider mounts inside Pyreon setup frame — provide() reaches descendants', () => {
+    const Ctx = createContext<string>('default')
+
+    const Provider: ComponentFn = (props) => {
+      provide(Ctx, props.value as string)
+      return props.children as never
+    }
+    nativeCompat(Provider)
+
+    const Consumer: ComponentFn = () => {
+      const value = useContext(Ctx)
+      return h('span', { 'data-value': value }, value)
+    }
+    nativeCompat(Consumer)
+
+    const el = container()
+    mount(jsx(Provider, { value: 'native', children: jsx(Consumer, {}) }), el)
+
+    const span = el.querySelector('span')
+    expect(span?.getAttribute('data-value')).toBe('native')
+    expect(span?.textContent).toBe('native')
+  })
+})