@solidjs/signals 0.3.2 → 0.4.0

package/dist/types/{core/boundaries.d.ts → boundaries.d.ts}

@@ -1,6 +1,5 @@
-import { Computation } from "./core.js";
-import { type Effect } from "./effect.js";
-import { Queue } from "./scheduler.js";
+import { Computation, Queue } from "./core/index.js";
+import type { Effect } from "./core/index.js";
 export declare class CollectionQueue extends Queue {
     _collectionType: number;
     _nodes: Set<Effect>;
@@ -16,3 +15,7 @@ export declare enum BoundaryMode {
 export declare function createBoundary<T>(fn: () => T, condition: () => BoundaryMode): () => T | undefined;
 export declare function createSuspense(fn: () => any, fallback: () => any): () => any;
 export declare function createErrorBoundary<U>(fn: () => any, fallback: (error: unknown, reset: () => void) => U): () => any;
+export declare function flatten(children: any, options?: {
+    skipNonRendered?: boolean;
+    doNotUnwrap?: boolean;
+}): any;

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

@@ -29,8 +29,10 @@
 import { type Flags } from "./flags.js";
 import { Owner } from "./owner.js";
 export interface SignalOptions<T> {
+    id?: string;
     name?: string;
     equals?: ((prev: T, next: T) => boolean) | false;
+    pureWrite?: boolean;
     unobserved?: () => void;
 }
 interface SourceType {
@@ -62,6 +64,7 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
     _name: string | undefined;
     _equals: false | ((a: T, b: T) => boolean);
     _unobserved: (() => void) | undefined;
+    _pureWrite: boolean;
     /** Whether the computation is an error or has ancestors that are unresolved */
     _stateFlags: number;
     /** Which flags raised by sources are handled, vs. being passed through. */
@@ -130,7 +133,7 @@ export declare function untrack<T>(fn: () => T): T;
  */
 export declare function hasUpdated(fn: () => any): boolean;
 /**
- * Returns an accessor that is true if the given function contains async signals are out of date.
+ * Returns an accessor that is true if the given function contains async signals that are out of date.
  */
 export declare function isPending(fn: () => any): boolean;
 export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
@@ -151,8 +154,4 @@ export declare function runWithObserver<T>(observer: Computation, run: () => T):
  */
 export declare function compute<T>(owner: Owner | null, fn: (val: T) => T, observer: Computation<T>): T;
 export declare function compute<T>(owner: Owner | null, fn: (val: undefined) => T, observer: null): T;
-export declare function flatten(children: any, options?: {
-    skipNonRendered?: boolean;
-    doNotUnwrap?: boolean;
-}): any;
 export {};

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

@@ -7,7 +7,7 @@ import { Computation, type SignalOptions } from "./core.js";
  */
 export declare class Effect<T = any> extends Computation<T> {
     _effect: (val: T, prev: T | undefined) => void | (() => void);
-    _onerror: ((err: unknown) => void | (() => void)) | undefined;
+    _onerror: ((err: unknown, cleanup: () => void) => void) | undefined;
     _cleanup: (() => void) | undefined;
     _modified: boolean;
     _prevValue: T | undefined;
@@ -20,7 +20,7 @@ export declare class Effect<T = any> extends Computation<T> {
     _notify(state: number, skipQueue?: boolean): void;
     _setError(error: unknown): void;
     _disposeNode(): void;
-    _runEffect(): void;
+    _runEffect(type: number): void;
 }
 export declare class EagerComputation<T = any> extends Computation<T> {
     constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
@@ -28,7 +28,8 @@ export declare class EagerComputation<T = any> extends Computation<T> {
     });
     _notify(state: number, skipQueue?: boolean): void;
 }
-export declare class ProjectionComputation extends Computation {
+export declare class FirewallComputation extends Computation {
+    firewall: boolean;
     constructor(compute: () => void);
     _notify(state: number, skipQueue?: boolean): void;
 }

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

@@ -1,4 +1,3 @@
-import type { Owner } from "./owner.js";
 export declare class NotReadyError extends Error {
 }
 export declare class NoOwnerError extends Error {
@@ -7,9 +6,3 @@ export declare class NoOwnerError extends Error {
 export declare class ContextNotFoundError extends Error {
     constructor();
 }
-export declare class EffectError extends Error {
-    constructor(effect: Function, cause: unknown);
-}
-export interface ErrorHandler {
-    (error: unknown, node: Owner): void;
-}

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

@@ -1,9 +1,7 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError, type ErrorHandler } from "./error.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
 export { Owner, createContext, getContext, setContext, hasContext, getOwner, onCleanup, type Context, type ContextRecord, type Disposable } from "./owner.js";
-export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, flatten, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
+export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
-export { flushSync, type IQueue, Queue } from "./scheduler.js";
-export { createSuspense, createErrorBoundary, createBoundary, type BoundaryMode } from "./boundaries.js";
-export { SUPPORTS_PROXY } from "./constants.js";
-export { tryCatch, type TryCatchResult } from "./utils.js";
+export { flush, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
+export * from "./constants.js";
 export * from "./flags.js";

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

@@ -1,9 +1,8 @@
-import type { Computation } from "./core.js";
-import type { Effect } from "./effect.js";
 export declare function getClock(): number;
 export declare function incrementClock(): void;
+type QueueCallback = (type: number) => void;
 export interface IQueue {
-    enqueue<T extends Computation | Effect>(type: number, node: T): void;
+    enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;
     flush(): void;
     addChild(child: IQueue): void;
@@ -15,10 +14,10 @@ export interface IQueue {
 export declare class Queue implements IQueue {
     _parent: IQueue | null;
     _running: boolean;
-    _queues: [Effect[], Effect[]];
+    _queues: [QueueCallback[], QueueCallback[]];
     _children: IQueue[];
     created: number;
-    enqueue<T extends Computation | Effect>(type: number, node: T): void;
+    enqueue(type: number, fn: QueueCallback): void;
     run(type: number): void;
     flush(): void;
     addChild(child: IQueue): void;
@@ -28,6 +27,7 @@ export declare class Queue implements IQueue {
 export declare const globalQueue: Queue;
 /**
  * By default, changes are batched on the microtask queue which is an async process. You can flush
- * the queue synchronously to get the latest updates by calling `flushSync()`.
+ * the queue synchronously to get the latest updates by calling `flush()`.
  */
-export declare function flushSync(): void;
+export declare function flush(): void;
+export {};

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
-export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flatten, flushSync, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, tryCatch, runWithObserver, createErrorBoundary, createSuspense, createBoundary, SUPPORTS_PROXY } from "./core/index.js";
-export type { ErrorHandler, SignalOptions, BoundaryMode, TryCatchResult, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, runWithObserver, SUPPORTS_PROXY } from "./core/index.js";
+export type { SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
 export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./signals.js";
 export * from "./store/index.js";
+export { createSuspense, createErrorBoundary, createBoundary, flatten, type BoundaryMode } from "./boundaries.js";

package/dist/types/signals.d.ts

@@ -10,6 +10,10 @@ export type Setter<in out T> = {
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
 export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
+export type EffectBundle<Prev, Next extends Prev = Prev> = {
+    effect: EffectFunction<Prev, Next>;
+    error: (err: unknown, cleanup: () => void) => void;
+};
 export interface EffectOptions {
     name?: string;
     defer?: boolean;
@@ -77,7 +81,9 @@ export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-async
  */
-export declare function createAsync<T>(compute: (prev?: T) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T>;
+export declare function createAsync<T>(compute: (prev: T | undefined, refreshing: boolean) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T> & {
+    refresh: () => void;
+};
 /**
  * Creates a reactive effect that runs after the render phase
  * ```typescript
@@ -96,8 +102,8 @@ export declare function createAsync<T>(compute: (prev?: T) => Promise<T> | Async
  *
  * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>, error?: (err: unknown) => void): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, error: ((err: unknown) => void) | undefined, value: Init, options?: EffectOptions): void;
+export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next> | EffectBundle<NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next> | EffectBundle<Next, Next>, value: Init, options?: EffectOptions): void;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -140,3 +146,37 @@ export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Runs the given function and returns a tuple with the result or an error.
+ * If the function throws an error, it will be caught and returned as the first element of the tuple.
+ * If the function returns a promise, it will resolve to a tuple with the result or an error.
+ *
+ * @param fn The function to run.
+ * @returns A tuple with either [undefined, result] or [error].
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/try-catch
+ */
+export type TryCatchResult<T, E> = [undefined, T] | [E];
+export declare function tryCatch<T, E = Error>(fn: () => Promise<T>): Promise<TryCatchResult<T, E>>;
+export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E>;
+/**
+ * Runs the given function in a transition scope, allowing for batch updates and optimizations.
+ * This is useful for grouping multiple state updates together to avoid unnecessary re-renders.
+ *
+ * @param fn A function that receives a resume function to continue the transition.
+ * The resume function can be called with another function to continue the transition.
+ *
+ * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
+ */
+export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any>): void;
+/**
+ * Creates an optimistic signal that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ *
+ * @param initial The initial value of the signal.
+ * @param compute An optional function to compute the next value based on the previous value and change.
+ * @param options Optional signal options.
+ *
+ * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
+ */
+export declare function createOptimistic<T, U>(initial: T, compute?: (prev: T, change: U) => void, options?: SignalOptions<T>): [Accessor<T>, (v: U) => void];

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

@@ -1,6 +1,6 @@
 export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./store.js";
 export type { Merge, Omit } from "./utils.js";
-export { unwrap, isWrappable, createStore, deep, $RAW, $TRACK, $PROXY, $TARGET } from "./store.js";
+export { isWrappable, createStore, deep, $TRACK, $PROXY, $TARGET } from "./store.js";
 export { createProjection } from "./projection.js";
 export { reconcile } from "./reconcile.js";
-export { merge, omit } from "./utils.js";
+export { snapshot, merge, omit } from "./utils.js";

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

@@ -1,8 +1,7 @@
-import { type Store, type StoreSetter } from "./store.js";
+import { type Store } from "./store.js";
 /**
  * Creates a mutable derived value
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
 export declare function createProjection<T extends Object>(fn: (draft: T) => void, initialValue?: T): Store<T>;
-export declare function wrapProjection<T>(fn: (draft: T) => void, store: Store<T>, setStore: StoreSetter<T>): [Store<T>, StoreSetter<T>];

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

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

@@ -3,33 +3,31 @@ export type Store<T> = Readonly<T>;
 export type StoreSetter<T> = (fn: (state: T) => void) => void;
 type DataNode = Computation<any>;
 type DataNodes = Record<PropertyKey, DataNode>;
-declare const $RAW: unique symbol, $TRACK: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol;
-export declare const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
-export { $PROXY, $TRACK, $RAW, $TARGET };
+export declare const $TRACK: unique symbol, $DEEP: unique symbol, $TARGET: unique symbol, $PROXY: unique symbol, $DELETED: unique symbol;
+export declare const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_NODE = "n", STORE_HAS = "h", STORE_WRAP = "w", STORE_LOOKUP = "l";
 export type StoreNode = {
+    [$PROXY]: any;
     [STORE_VALUE]: Record<PropertyKey, any>;
+    [STORE_OVERRIDE]?: Record<PropertyKey, any>;
     [STORE_NODE]?: DataNodes;
     [STORE_HAS]?: DataNodes;
+    [STORE_WRAP]?: (value: any, target?: StoreNode) => any;
+    [STORE_LOOKUP]?: WeakMap<any, any>;
 };
 export declare namespace SolidStore {
     interface Unwrappable {
     }
 }
 export type NotWrappable = string | number | bigint | symbol | boolean | Function | null | undefined | SolidStore.Unwrappable[keyof SolidStore.Unwrappable];
-export declare function wrap<T extends Record<PropertyKey, any>>(value: T): T;
+export declare function createStoreProxy<T extends object>(value: T, traps?: ProxyHandler<StoreNode>, extend?: Record<PropertyKey, any>): any;
+export declare const storeLookup: WeakMap<object, 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;
-/**
- * Returns the underlying data in the store without a proxy.
- * @param item store proxy object
- * @example
- * ```js
- * const initial = {z...};
- * const [state, setState] = createStore(initial);
- * initial === state; // => false
- * initial === unwrap(state); // => true
- * ```
- */
-export declare function unwrap<T>(item: T, deep?: boolean, set?: Set<unknown>): T;
+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>;
+export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => void): void;
 export declare function createStore<T extends object = {}>(store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare function createStore<T extends object = {}>(fn: (store: T) => void, store: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
 export declare function deep<T extends object>(store: Store<T>): Store<any>;
+export {};

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

@@ -1,3 +1,10 @@
+/**
+ * Returns a non reactive copy of the store object.
+ * It will attempt to preserver the original reference unless the value has been modified.
+ * @param item store proxy object
+ */
+export declare function snapshot<T>(item: T): T;
+export declare function snapshot<T>(item: T, map?: Map<unknown, unknown>, lookup?: WeakMap<any, any>): 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.3.2",
+  "version": "0.4.0",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",

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

@@ -1,4 +0,0 @@
-export declare function isUndefined(value: any): value is undefined;
-export type TryCatchResult<T, E> = [undefined, T] | [E];
-export declare function tryCatch<T, E = Error>(fn: () => Promise<T>): Promise<TryCatchResult<T, E>>;
-export declare function tryCatch<T, E = Error>(fn: () => T): TryCatchResult<T, E>;