@pyreon/solid-compat 0.13.1 → 0.15.0

package/lib/types/index.d.ts

@@ -1,19 +1,43 @@
-import { ComponentFn, ErrorBoundary, For, LazyComponent, Match, Props, Show, Suspense, Switch, VNodeChild, createContext as pyreonCreateContext, useContext as pyreonUseContext } from "@pyreon/core";
+import { ComponentFn, Context, ErrorBoundary, For, LazyComponent, Match, Props, Show, Suspense, Switch, VNodeChild } from "@pyreon/core";
 import { EffectScope, batch as pyreonBatch, runUntracked } from "@pyreon/reactivity";
 
 //#region src/index.d.ts
+/** Solid-compatible read accessor type */
+type Accessor<T> = () => T;
+/** Solid-compatible setter type */
+type Setter<T> = (v: T | ((prev: T) => T)) => void;
+/** Solid-compatible signal tuple type */
+type Signal<T> = [Accessor<T>, Setter<T>];
+/** Solid-compatible owner type */
+type Owner = EffectScope;
+/** Solid-compatible component type */
+type Component<P = object> = (props: P) => VNodeChild;
+/** Solid-compatible parent component type (includes children) */
+type ParentComponent<P = object> = (props: P & {
+  children?: VNodeChild;
+}) => VNodeChild;
+/** Solid-compatible flow component type */
+type FlowComponent<P = object> = Component<P>;
+/** Solid-compatible void component type (no children) */
+type VoidComponent<P = object> = Component<P>;
 type SignalGetter<T> = () => T;
 type SignalSetter<T> = (v: T | ((prev: T) => T)) => void;
-declare function createSignal<T>(initialValue: T): [SignalGetter<T>, SignalSetter<T>];
+interface CreateSignalOptions<T> {
+  equals?: false | ((prev: T, next: T) => boolean);
+}
+declare function createSignal<T>(initialValue: T, options?: CreateSignalOptions<T>): [SignalGetter<T>, SignalSetter<T>];
 /**
  * Solid-compatible `createEffect` — creates a reactive side effect.
  *
+ * Supports the `(prev) => next` signature with an optional initial value,
+ * matching Solid's `createEffect<T>(fn: (prev: T) => T, initialValue: T)`.
+ *
  * In component context: hook-indexed, only created on first render. The effect
  * uses Pyreon's native tracking so signal reads are automatically tracked.
  * A re-entrance guard prevents infinite loops from signal writes inside
  * the effect.
  */
-declare function createEffect(fn: () => void): void;
+declare function createEffect<T>(fn: ((prev?: T) => T) | (() => void), initialValue?: T): void;
 /**
  * Solid-compatible `createRenderEffect` — same as createEffect.
  * In Solid, this runs during the render phase; here it runs as a Pyreon effect.
@@ -22,14 +46,19 @@ declare function createRenderEffect(fn: () => void): void;
 /**
  * Solid-compatible `createMemo` — derives a value from reactive sources.
  *
+ * Supports the `(prev) => next` signature with an optional initial value,
+ * matching Solid's `createMemo<T>(fn: (prev: T) => T, initialValue: T)`.
+ *
  * In component context: hook-indexed, only created on first render.
  * Uses Pyreon's native computed for auto-tracking.
  */
-declare function createMemo<T>(fn: () => T): () => T;
+declare function createMemo<T>(fn: ((prev?: T) => T) | (() => T), initialValue?: T): () => T;
 declare function createRoot<T>(fn: (dispose: () => void) => T): T;
 type AccessorArray = readonly (() => unknown)[];
 type OnEffectFunction<D, V> = (input: D, prevInput: D | undefined, prev: V | undefined) => V;
-declare function on<S extends (() => unknown) | AccessorArray, V>(deps: S, fn: OnEffectFunction<S extends (() => infer R) ? R : S extends readonly (() => infer R)[] ? R[] : never, V>): () => V | undefined;
+declare function on<S extends (() => unknown) | AccessorArray, V>(deps: S, fn: OnEffectFunction<S extends (() => infer R) ? R : S extends readonly (() => infer R)[] ? R[] : never, V>, options?: {
+  defer?: boolean;
+}): () => V | undefined;
 /**
  * Solid-compatible `onMount` — runs once after the component's first render.
  */
@@ -52,8 +81,167 @@ declare function lazy<P extends Props>(loader: () => Promise<{
     default: ComponentFn<P>;
   }>;
 };
+declare const SOLID_CTX: unique symbol;
+/**
+ * Solid-compatible context with a Provider component that uses Pyreon's
+ * native tree-scoped context stack for proper nesting (inner Provider
+ * overrides outer for its subtree).
+ */
+interface SolidContext<T> {
+  readonly [SOLID_CTX_BRAND]: true;
+  readonly id: symbol;
+  readonly defaultValue: T | undefined;
+  Provider: (props: Record<string, unknown>) => unknown;
+}
+declare const SOLID_CTX_BRAND: typeof SOLID_CTX;
+/**
+ * Solid-compatible `createContext` — creates a context with a `.Provider`
+ * component. Uses Pyreon's native context stack for tree-scoped nesting.
+ */
+declare function createContext<T>(defaultValue?: T): SolidContext<T>;
+/**
+ * Solid-compatible `useContext` — reads the nearest provided value for a context.
+ * Works with both compat contexts (from this module's `createContext`) and
+ * Pyreon native contexts (from `@pyreon/core`).
+ */
+declare function useContext<T>(context: SolidContext<T> | Context<T>): T;
 declare function getOwner(): EffectScope | null;
 declare function runWithOwner<T>(owner: EffectScope | null, fn: () => T): T;
+/**
+ * Solid-compatible resource — async data fetching with reactive source tracking.
+ * Returns `[resource, { mutate, refetch }]` where `resource()` is the data accessor
+ * with `.loading`, `.error`, and `.latest` reactive properties.
+ *
+ * When the resource is loading and read inside a Suspense boundary, the accessor
+ * throws the fetch promise so Suspense can catch it. It also integrates with
+ * Pyreon's `__loading` protocol so `<Suspense>` can detect it.
+ */
+interface Resource<T> {
+  (): T | undefined;
+  loading: boolean;
+  error: Error | undefined;
+  latest: T | undefined;
+}
+type ResourceReturn<T> = [Resource<T>, {
+  mutate: (v: T | ((prev: T | undefined) => T)) => void;
+  refetch: () => void;
+}];
+declare function createResource<T>(fetcher: (info: {
+  value: T | undefined;
+}) => Promise<T> | T, options?: {
+  initialValue?: T;
+}): ResourceReturn<T>;
+declare function createResource<T, S = true>(source: (() => S) | true, fetcher: (source: S, info: {
+  value: T | undefined;
+}) => Promise<T> | T, options?: {
+  initialValue?: T;
+}): ResourceReturn<T>;
+/**
+ * Solid-compatible `createStore` — creates a deeply reactive proxy-based store.
+ *
+ * Returns `[store, setStore]` where:
+ * - `store` is a recursive proxy that lazily creates per-path signals for fine-grained tracking
+ * - `setStore` supports Solid's path-based setter API:
+ *   - `setStore('key', value)` — set a top-level key
+ *   - `setStore('nested', 'key', value)` — set a nested path
+ *   - `setStore('key', prev => next)` — functional update at a path
+ *   - `setStore('todos', 0, 'done', true)` — numeric index into arrays
+ *   - `setStore('todos', t => t.done, 'text', 'x')` — filter predicate on arrays
+ *   - `setStore(fn)` — mutator function (receives a draft clone)
+ */
+type SetStoreFunction<_T> = {
+  (...args: unknown[]): void;
+};
+declare function createStore<T extends object>(initialValue: T): [T, SetStoreFunction<T>];
+/**
+ * Solid-compatible `reconcile` — replaces the entire store state with the given value.
+ * Used with setStore: `setStore(reconcile(newData))`
+ */
+declare function reconcile<T extends object>(value: T): (state: T) => T;
+/**
+ * Solid-compatible `unwrap` — returns a deep clone of the store's raw data,
+ * stripping the reactive proxy.
+ */
+declare function unwrap<T>(value: T): T;
+/**
+ * Solid-compatible `produce` — creates an Immer-like updater function for stores.
+ * Returns a function that clones the state, applies mutations, and returns the result.
+ */
+declare function produce<T extends object>(fn: (state: T) => void): (state: T) => T;
+/**
+ * Solid-compatible `startTransition` — runs a function as a transition.
+ * In Pyreon, this is a no-op wrapper that calls the function synchronously.
+ */
+declare function startTransition(fn: () => void): void;
+/**
+ * Solid-compatible `useTransition` — returns `[isPending, startTransition]`.
+ * In Pyreon, transitions are not deferred — isPending is always false.
+ */
+declare function useTransition(): [() => boolean, (fn: () => void) => void];
+interface Observer<T> {
+  next: (v: T) => void;
+}
+interface Subscription {
+  unsubscribe: () => void;
+}
+interface Observable<T> {
+  subscribe: (observer: Observer<T>) => Subscription;
+}
+/**
+ * Solid-compatible `observable` — converts a signal accessor to an observable.
+ * Returns an object with a `subscribe` method that tracks signal changes.
+ */
+declare function observable<T>(input: () => T): Observable<T>;
+/**
+ * Solid-compatible `from` — converts an observable or producer into a signal accessor.
+ * Accepts either a producer function `(setter) => cleanup` or an observable with `.subscribe()`.
+ */
+declare function from<T>(producer: ((setter: (v: T) => void) => () => void) | Observable<T>): () => T | undefined;
+/**
+ * Solid-compatible `mapArray` — maps a reactive list by item identity.
+ * Each item is a static value, while the index is a reactive accessor.
+ */
+declare function mapArray<T, U>(list: () => readonly T[], mapFn: (item: T, index: () => number) => U): () => U[];
+/**
+ * Solid-compatible `indexArray` — maps a reactive list by index position.
+ * Each item is a reactive accessor, while the index is a static number.
+ */
+declare function indexArray<T, U>(list: () => readonly T[], mapFn: (item: () => T, index: number) => U): () => U[];
+/**
+ * Solid-compatible `Index` — like `For` but keyed by index.
+ * Items are reactive accessors, indices are static numbers.
+ *
+ * In Solid, `<Index>` keeps DOM nodes stable per index position.
+ * Here we use a computed that maps items to `(item: () => T, index: number)`.
+ */
+declare function Index<T>(props: {
+  each: readonly T[] | (() => readonly T[]);
+  children: (item: () => T, index: number) => VNodeChild;
+}): VNodeChild;
+/**
+ * Solid-compatible `createUniqueId` — returns a unique string identifier.
+ */
+declare function createUniqueId(): string;
+/**
+ * Solid-compatible `DEV` — an object in dev mode, `undefined` in production.
+ * Used for conditional dev-only code: `if (DEV) { ... }`
+ */
+declare const DEV: {} | undefined;
+/**
+ * Solid-compatible `catchError` — wraps a function and catches synchronous errors.
+ */
+declare function catchError<T>(tryFn: () => T, onError: (err: Error) => void): T | undefined;
+/**
+ * Solid-compatible `createDeferred` — creates a memo that updates on next idle frame.
+ * In Pyreon there is no concurrent scheduling, so this behaves the same as `createMemo`.
+ */
+declare function createDeferred<T>(fn: () => T): () => T;
+/**
+ * Solid-compatible `createReaction` — manual tracking primitive.
+ * Returns a function that accepts a tracking function. When any tracked
+ * dependency changes, `onInvalidate` fires (but only after the first run).
+ */
+declare function createReaction(onInvalidate: () => void): (tracking: () => void) => void;
 //#endregion
-export { ErrorBoundary, For, Match, Show, SignalGetter, SignalSetter, Suspense, Switch, pyreonBatch as batch, children, createEffect as createComputed, createEffect, pyreonCreateContext as createContext, createMemo, createRenderEffect, createRoot, createSelector, createSignal, getOwner, lazy, mergeProps, on, onCleanup, onMount, runWithOwner, splitProps, runUntracked as untrack, pyreonUseContext as useContext };
+export { Accessor, Component, CreateSignalOptions, DEV, ErrorBoundary, FlowComponent, For, Index, Match, Owner, ParentComponent, Resource, ResourceReturn, SetStoreFunction, Setter, Show, Signal, SignalGetter, SignalSetter, SolidContext, Suspense, Switch, VoidComponent, pyreonBatch as batch, catchError, children, createEffect as createComputed, createEffect, createContext, createDeferred, createMemo, createReaction, createRenderEffect, createResource, createRoot, createSelector, createSignal, createStore, createUniqueId, from, getOwner, indexArray, lazy, mapArray, mergeProps, observable, on, onCleanup, onMount, produce, reconcile, runWithOwner, splitProps, startTransition, runUntracked as untrack, unwrap, useContext, useTransition };
 //# sourceMappingURL=index2.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pyreon/solid-compat",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "description": "SolidJS-compatible API shim for Pyreon — write Solid-style code that runs on Pyreon's reactive engine",
   "homepage": "https://github.com/pyreon/pyreon/tree/main/packages/solid-compat#readme",
   "bugs": {
@@ -14,6 +14,7 @@
   },
   "files": [
     "lib",
+    "!lib/**/*.map",
     "src",
     "README.md",
     "LICENSE"
@@ -47,17 +48,20 @@
     "build": "vl_rolldown_build",
     "dev": "vl_rolldown_build-watch",
     "test": "vitest run",
+    "test:browser": "vitest run --config ./vitest.browser.config.ts",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint .",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@pyreon/core": "^0.13.1",
-    "@pyreon/reactivity": "^0.13.1",
-    "@pyreon/runtime-dom": "^0.13.1"
+    "@pyreon/core": "^0.15.0",
+    "@pyreon/reactivity": "^0.15.0",
+    "@pyreon/runtime-dom": "^0.15.0"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "^20.8.9",
+    "@pyreon/test-utils": "^0.13.2",
+    "@vitest/browser-playwright": "^4.1.4",
     "happy-dom": "^20.8.3"
   }
 }

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 } }