@solidjs/signals 0.0.6 → 0.0.8

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

@@ -42,7 +42,7 @@ interface SourceType {
 }
 interface ObserverType {
     _sources: SourceType[] | null;
-    _notify: (state: number) => void;
+    _notify: (state: number, skipQueue?: boolean) => void;
     _handlerMask: Flags;
     _notifyFlags: (mask: Flags, newFlags: Flags) => void;
     _time: number;
@@ -51,6 +51,7 @@ interface ObserverType {
  * Returns the current observer.
  */
 export declare function getObserver(): ObserverType | null;
+export declare function getClock(): number;
 export declare function incrementClock(): void;
 export declare const UNCHANGED: unique symbol;
 export type UNCHANGED = typeof UNCHANGED;
@@ -66,9 +67,9 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
     _stateFlags: number;
     /** Which flags raised by sources are handled, vs. being passed through. */
     _handlerMask: number;
-    _error: Computation<boolean> | null;
     _loading: Computation<boolean> | null;
     _time: number;
+    _forceNotify: boolean;
     constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
     _read(): T;
     /**
@@ -92,17 +93,12 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
      * loading state changes
      */
     loading(): boolean;
-    /**
-     * Return true if the computation is the computation threw an error
-     * Triggers re-execution of the computation when the error state changes
-     */
-    error(): boolean;
     /** Update the computation with a new value. */
     write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
     /**
      * Set the current node's state, and recursively mark all of this node's observers as STATE_CHECK
      */
-    _notify(state: number): void;
+    _notify(state: number, skipQueue?: boolean): void;
     /**
      * Notify the computation that one of its sources has changed flags.
      *
@@ -147,7 +143,15 @@ export declare function hasUpdated(fn: () => any): boolean;
  * Returns true if the given function contains async signals that are not ready yet.
  */
 export declare function isPending(fn: () => any): boolean;
-export declare function latest<T>(fn: () => T): T | undefined;
+export type PossiblyResolved<T> = T extends Object ? RecursivePartial<T> : T;
+export type RecursivePartial<T> = {
+    [P in keyof T]?: PossiblyResolved<T[P]>;
+};
+/**
+ * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
+ */
+export declare function resolveSync<T>(fn: () => T): PossiblyResolved<T> | undefined;
+export declare function catchError(fn: () => void): unknown | undefined;
 /**
  * A convenient wrapper that calls `compute` with the `owner` and `observer` and is guaranteed
  * to reset the global context after the computation is finished even if an error is thrown.

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

@@ -7,16 +7,19 @@ import { type IQueue } from "./scheduler.js";
  * sources and recompute
  */
 export declare class Effect<T = any> extends Computation<T> {
-    _effect: (val: T, prev: T | undefined) => void;
+    _effect: (val: T, prev: T | undefined) => void | (() => void);
+    _error: ((err: unknown) => void | (() => void)) | undefined;
+    _cleanup: (() => void) | undefined;
     _modified: boolean;
     _prevValue: T | undefined;
     _type: typeof EFFECT_RENDER | typeof EFFECT_USER;
     _queue: IQueue;
-    constructor(initialValue: T, compute: () => T, effect: (val: T, prev: T | undefined) => void, options?: SignalOptions<T> & {
+    constructor(initialValue: T, compute: () => T, effect: (val: T, prev: T | undefined) => void | (() => void), error?: (err: unknown) => void | (() => void), options?: SignalOptions<T> & {
         render?: boolean;
+        defer?: boolean;
     });
     write(value: T, flags?: number): T;
-    _notify(state: number): void;
+    _notify(state: number, skipQueue?: boolean): void;
     _setError(error: unknown): void;
     _disposeNode(): void;
     _runEffect(): void;
@@ -24,5 +27,5 @@ export declare class Effect<T = any> extends Computation<T> {
 export declare class EagerComputation<T = any> extends Computation<T> {
     _queue: IQueue;
     constructor(initialValue: T, compute: () => T, options?: SignalOptions<T>);
-    _notify(state: number): void;
+    _notify(state: number, skipQueue?: boolean): void;
 }

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

@@ -6,6 +6,9 @@ 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): void;
 }

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

@@ -1,8 +1,8 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError, type ErrorHandler } 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, UNCHANGED, compute, type SignalOptions } from "./core.js";
+export { Computation, getObserver, isEqual, untrack, getClock, hasUpdated, isPending, resolveSync, catchError, UNCHANGED, compute, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
-export { flushSync, createBoundary, queueTask, type IQueue, Queue } from "./scheduler.js";
+export { flushSync, createBoundary, type IQueue, Queue } from "./scheduler.js";
 export { createSuspense } from "./suspense.js";
 export { SUPPORTS_PROXY } from "./constants.js";
 export * from "./flags.js";

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

@@ -2,7 +2,7 @@ import { Computation } from "./core.js";
 import type { Effect } from "./effect.js";
 export interface IQueue {
     enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): void;
+    run(type: number): boolean | void;
     flush(): void;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
@@ -12,7 +12,7 @@ export declare class Queue implements IQueue {
     _queues: [Computation[], Effect[], Effect[]];
     _children: IQueue[];
     enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): void;
+    run(type: number): true | undefined;
     flush(): void;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
@@ -23,5 +23,4 @@ export declare const globalQueue: Queue;
  * the queue synchronously to get the latest updates by calling `flushSync()`.
  */
 export declare function flushSync(): void;
-export declare function queueTask(fn: () => void): void;
 export declare function createBoundary<T>(fn: () => T, queue: IQueue): T;

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

@@ -5,7 +5,7 @@ export declare class SuspenseQueue extends Queue {
     _nodes: Set<Effect>;
     _fallback: boolean;
     _signal: Computation<boolean>;
-    run(type: number): void;
+    run(type: number): true | undefined;
     _update(node: Effect): void;
 }
 export declare function createSuspense(fn: () => any, fallback: () => any): () => any;

package/dist/types/index.d.ts

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

package/dist/types/map.d.ts

@@ -3,7 +3,7 @@ export type Maybe<T> = T | void | null | undefined | false;
 /**
  * Reactively transforms an array with a callback function - underlying helper for the `<For>` control flow
  *
- * similar to `Array.prototype.map`, but gets the value and index as accessos, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
+ * similar to `Array.prototype.map`, but gets the value and index as accessors, transforms only values that changed and returns an accessor and reactively tracks changes to the list.
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/map-array
  */
@@ -11,3 +11,11 @@ export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly
     keyed?: boolean | ((item: Item) => any);
     fallback?: Accessor<any>;
 }): Accessor<MappedItem[]>;
+/**
+ * Reactively repeats a callback function the count provided - underlying helper for the `<Repeat>` control flow
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/repeat
+ */
+export declare function repeat(count: Accessor<number>, map: (index: number) => any, options?: {
+    fallback?: Accessor<any>;
+}): Accessor<any[]>;

package/dist/types/signals.d.ts

@@ -87,14 +87,15 @@ export declare function createAsync<T>(compute: (prev?: T) => Promise<T> | Async
  * ): void;
  * ```
  * @param compute a function that receives its previous or the initial value, if set, and returns a new value used to react on a computation
- * @param effect a function that receives the new value and is used to perform side effects
+ * @param effect a function that receives the new value and is used to perform side effects, return a cleanup function to run on disposal
+ * @param error an optional function that receives an error if thrown during the computation
  * @param value an optional initial value for the computation; if set, fn will never receive undefined as first argument
  * @param options allows to set a name in dev mode for debugging purposes
  *
  * @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>): void;
-export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+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;
 /**
  * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
  * ```typescript
@@ -139,3 +140,23 @@ export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T |
  * @description https://docs.solidjs.com/reference/reactive-utilities/catch-error
  */
 export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error: unknown, reset: () => void) => U): Accessor<T | U>;
+/**
+ * Returns a promise of the resolved value of a reactive expression
+ * @param fn a reactive expression to resolve
+ */
+export declare function resolve<T>(fn: () => T): Promise<T>;
+/**
+ * Creates a reactive computation that runs after the render phase with flexible tracking
+ * ```typescript
+ * export function createReaction(
+ *   effect: () => void,
+ *   options?: { name?: string }
+ * ): (fn: () => void) => void;
+ * ```
+ * @param effect a function that is called when tracked function is invalidated.
+ * @param error an optional function that receives an error if thrown during tracking
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-reaction
+ */
+export declare function createReaction(effect: () => (() => void) | void, error?: (err: unknown) => (() => void) | void, options?: EffectOptions): (tracking: () => void) => void;

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

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

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

@@ -0,0 +1,6 @@
+/**
+ * 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): any;

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

@@ -32,9 +32,3 @@ export declare function isWrappable<T>(obj: T | NotWrappable): obj is T;
 export declare function unwrap<T>(item: T, deep?: boolean, set?: Set<unknown>): T;
 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>];
-/**
- * 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): Readonly<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",