@solidjs/signals 0.12.0 → 0.13.1

package/dist/types/boundaries.d.ts

@@ -8,13 +8,17 @@ export declare class CollectionQueue extends Queue {
     _sources: Set<Computed<any>>;
     _disabled: Signal<boolean>;
     _initialized: boolean;
+    _onFn: (() => any) | undefined;
+    _prevOn: any;
     constructor(type: number);
     run(type: number): void;
     notify(node: Effect<any>, type: number, flags: number, error?: any): boolean;
     checkSources(): void;
 }
-export declare function createLoadBoundary(fn: () => any, fallback: () => any): () => unknown;
-export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => unknown;
+export declare function createLoadingBoundary(fn: () => any, fallback: () => any, options?: {
+    on?: () => any;
+}): import("./signals.js").Accessor<unknown>;
+export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): import("./signals.js").Accessor<unknown>;
 export declare function flatten(children: any, options?: {
     skipNonRendered?: boolean;
     doNotUnwrap?: boolean;

package/dist/types/core/external.d.ts

@@ -0,0 +1,26 @@
+export type ExternalSourceFactory = (fn: (prev: any) => any, trigger: () => void) => ExternalSource;
+export interface ExternalSource {
+    track: (prev: any) => any;
+    dispose: () => void;
+}
+export interface ExternalSourceConfig {
+    factory: ExternalSourceFactory;
+    untrack?: <T>(fn: () => T) => T;
+}
+export declare let externalSourceConfig: {
+    factory: ExternalSourceFactory;
+    untrack: <T>(fn: () => T) => T;
+} | null;
+/**
+ * Registers a factory that bridges external reactive systems (e.g. MobX, Vue refs)
+ * into Solid's tracking graph. Every computation will be wrapped so that the
+ * external library can track its own dependencies alongside Solid's.
+ *
+ * Multiple calls pipe together: each new factory wraps the previous one.
+ *
+ * @param config.factory receives `(fn, trigger)` — wrap fn execution in external tracking,
+ *   call trigger when external deps change. Return `{ track, dispose }`.
+ * @param config.untrack optional wrapper for `untrack` — disables external tracking too.
+ */
+export declare function enableExternalSource(config: ExternalSourceConfig): void;
+export declare function _resetExternalSourceConfig(): void;

package/dist/types/core/index.d.ts

@@ -1,10 +1,11 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
-export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, } from "./core.js";
+export { isEqual, untrack, runWithOwner, computed, signal, read, setSignal, optimisticSignal, optimisticComputed, isPending, latest, refresh, isRefreshing, staleValues, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots } from "./core.js";
+export { enableExternalSource, _resetExternalSourceConfig, type ExternalSourceFactory, type ExternalSource, type ExternalSourceConfig } from "./external.js";
 export { createOwner, createRoot, dispose, getNextChildId, getObserver, getOwner, isDisposed, onCleanup, peekNextChildId } from "./owner.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
 export { handleAsync } from "./async.js";
 export type { Computed, Disposable, FirewallSignal, Link, Owner, Root, Signal, NodeOptions } from "./types.js";
 export { effect, trackedEffect, type Effect, type TrackedEffect } from "./effect.js";
 export { action } from "./action.js";
-export { flush, Queue, GlobalQueue, trackOptimisticStore, setOnUnhandledAsync, type IQueue, type QueueCallback } from "./scheduler.js";
+export { flush, Queue, GlobalQueue, trackOptimisticStore, enforceLoadingBoundary, type IQueue, type QueueCallback } from "./scheduler.js";
 export * from "./constants.js";

package/dist/types/core/lanes.d.ts

@@ -35,11 +35,10 @@ export declare function resolveLane(el: {
     _optimisticLane?: OptimisticLane;
 }): OptimisticLane | undefined;
 /**
- * Check if a node has an active optimistic override (pending value differs from base).
+ * Check if a node has an active optimistic override.
  */
 export declare function hasActiveOverride(el: {
-    _optimistic?: boolean;
-    _pendingValue?: any;
+    _overrideValue?: any;
 }): boolean;
 /**
  * Assign or merge a lane onto a node. At convergence points (node already has
@@ -47,6 +46,5 @@ export declare function hasActiveOverride(el: {
  */
 export declare function assignOrMergeLane(el: {
     _optimisticLane?: OptimisticLane;
-    _optimistic?: boolean;
-    _pendingValue?: any;
+    _overrideValue?: any;
 }, sourceLane: OptimisticLane): void;

package/dist/types/core/scheduler.d.ts

@@ -8,7 +8,9 @@ export declare const zombieQueue: Heap;
 export declare let clock: number;
 export declare let activeTransition: Transition | null;
 export declare let projectionWriteActive: boolean;
-export declare function setOnUnhandledAsync(fn: (() => void) | null): void;
+export declare let _hitUnhandledAsync: boolean;
+export declare function resetUnhandledAsync(): void;
+export declare function enforceLoadingBoundary(enabled: boolean): void;
 export declare function setProjectionWriteActive(value: boolean): void;
 export type QueueCallback = (type: number) => void;
 type QueueStub = {

package/dist/types/core/types.d.ts

@@ -32,7 +32,7 @@ export interface RawSignal<T> {
     _time: number;
     _transition: Transition | null;
     _pendingValue: T | typeof NOT_PENDING;
-    _optimistic?: boolean;
+    _overrideValue?: T | typeof NOT_PENDING;
     _optimisticLane?: OptimisticLane;
     _pendingSignal?: Signal<boolean>;
     _latestValueComputed?: Computed<T>;

package/dist/types/index.d.ts

@@ -1,6 +1,7 @@
-export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, onCleanup, isDisposed, getObserver, isEqual, untrack, isPending, latest, isRefreshing, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, setOnUnhandledAsync, } from "./core/index.js";
-export type { Owner, Context, ContextRecord, IQueue } from "./core/index.js";
-export * from "./signals.js";
+export { $REFRESH, ContextNotFoundError, NoOwnerError, NotReadyError, action, createContext, createOwner, createRoot, runWithOwner, flush, getNextChildId, peekNextChildId, getContext, setContext, getOwner, onCleanup, isDisposed, getObserver, isEqual, untrack, isPending, latest, isRefreshing, refresh, SUPPORTS_PROXY, setSnapshotCapture, markSnapshotScope, releaseSnapshotScope, clearSnapshots, enforceLoadingBoundary, enableExternalSource } from "./core/index.js";
+export type { Owner, Context, ContextRecord, IQueue, ExternalSourceFactory, ExternalSource, ExternalSourceConfig } from "./core/index.js";
+export { createSignal, createMemo, createEffect, createRenderEffect, createTrackedEffect, createReaction, createOptimistic, resolve, onSettled } from "./signals.js";
+export type { Accessor, Setter, Signal, ComputeFunction, EffectFunction, EffectBundle, EffectOptions, SignalOptions, MemoOptions, NoInfer } from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
-export { createLoadBoundary, createErrorBoundary, flatten } from "./boundaries.js";
+export { createLoadingBoundary, createErrorBoundary, flatten } from "./boundaries.js";

package/dist/types/signals.d.ts

@@ -1,4 +1,5 @@
 export type Accessor<T> = () => T;
+export declare function accessor<T>(node: any): Accessor<T>;
 export type Setter<in out T> = {
     <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
     <U extends T>(value: (prev: T) => U): U;

package/dist/types/store/index.d.ts

@@ -1,9 +1,9 @@
 export type { Store, StoreSetter, StoreNode, StoreOptions, ProjectionOptions, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
-export { isWrappable, createStore, deep, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { isWrappable, createStore, $TRACK, $PROXY, $TARGET } from "./store.js";
 export { createProjection } from "./projection.js";
 export { createOptimisticStore } from "./optimistic.js";
 export { reconcile } from "./reconcile.js";
 export { storePath } from "./storePath.js";
 export type { PathSetter, Part, StorePathRange, ArrayFilterFn, CustomPartial } from "./storePath.js";
-export { snapshot, merge, omit } from "./utils.js";
+export { snapshot, deep, merge, omit } from "./utils.js";

package/dist/types/store/reconcile.d.ts

@@ -1 +1 @@
-export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any), all?: boolean): (state: U) => void;
+export declare function reconcile<T extends U, U>(value: T, key: string | ((item: NonNullable<any>) => any)): (state: U) => void;

package/dist/types/store/store.d.ts

@@ -10,13 +10,11 @@ export interface StoreOptions {
 export interface ProjectionOptions extends StoreOptions {
     /** Key property name or function for reconciliation identity */
     key?: string | ((item: NonNullable<any>) => any);
-    /** When true, reconciles all properties (not just tracked ones) */
-    all?: boolean;
 }
 export type NoFn<T> = T extends Function ? never : T;
 type DataNode = Signal<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
-export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
 export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p";
 export type StoreNode = {
     [$PROXY]: any;
@@ -41,6 +39,7 @@ export declare const storeLookup: WeakMap<WeakKey, any>;
 export declare function wrap<T extends Record<PropertyKey, any>>(value: T, target?: StoreNode): T;
 export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function setWriteOverride(value: boolean): void;
+export declare function trackSelf(target: StoreNode, symbol?: symbol): void;
 export declare function getKeys(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, enumerable?: boolean): PropertyKey[];
 export declare function getPropertyDescriptor(source: Record<PropertyKey, any>, override: Record<PropertyKey, any> | undefined, property: PropertyKey): PropertyDescriptor | undefined;
 export declare const storeTraps: ProxyHandler<StoreNode>;
@@ -66,5 +65,4 @@ export declare function createStore<T extends object = {}>(store: NoFn<T> | Stor
 export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store?: NoFn<T> | Store<NoFn<T>>, options?: ProjectionOptions): [get: Store<T> & {
     [$REFRESH]: any;
 }, set: StoreSetter<T>];
-export declare function deep<T extends object>(store: Store<T>): Store<T>;
 export {};

package/dist/types/store/utils.d.ts

@@ -1,3 +1,4 @@
+import { type Store } from "./store.js";
 /**
  * Returns a non reactive copy of the store object.
  * It will attempt to preserver the original reference unless the value has been modified.
@@ -5,6 +6,13 @@
  */
 export declare function snapshot<T>(item: T): T;
 export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): T;
+/**
+ * Returns a non-reactive snapshot of the store while subscribing to all nested changes.
+ * Subscribes to `$TRACK` at every level so that any deep change triggers recomputation,
+ * and returns plain (non-proxy) data. Works correctly with `reconcile()`.
+ * @param store store proxy object
+ */
+export declare function deep<T extends object>(store: Store<T>): T;
 type DistributeOverride<T, F> = T extends undefined ? F : T;
 type Override<T, U> = T extends any ? U extends any ? {
     [K in keyof T]: K extends keyof U ? DistributeOverride<U[K], T[K]> : T[K];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "SolidJS' standalone reactivity implementation",
   "author": "Ryan Carniato",
   "license": "MIT",