@solidjs/signals 0.0.7 → 0.0.9

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

@@ -7,8 +7,7 @@
 export declare const STATE_CLEAN = 0;
 export declare const STATE_CHECK = 1;
 export declare const STATE_DIRTY = 2;
-export declare const STATE_UNINITIALIZED = 3;
-export declare const STATE_DISPOSED = 4;
+export declare const STATE_DISPOSED = 3;
 export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;

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;
@@ -58,6 +59,7 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
     _sources: SourceType[] | null;
     _observers: ObserverType[] | null;
     _value: T | undefined;
+    _error: unknown;
     _compute: null | ((p?: T) => T);
     _name: string | undefined;
     _equals: false | ((a: T, b: T) => boolean);
@@ -66,9 +68,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 +94,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.
      *
@@ -144,14 +141,18 @@ export declare function untrack<T>(fn: () => T): T;
  */
 export declare function hasUpdated(fn: () => any): boolean;
 /**
- * Returns true if the given function contains async signals that are not ready yet.
+ * Returns true if the given function contains async signals are out of date.
+ */
+export declare function isStale(fn: () => any): boolean;
+/**
+ * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
  */
-export declare function isPending(fn: () => any): boolean;
-export declare function latest<T>(fn: () => T): T | undefined;
+export declare function latest<T>(fn: () => T): T;
+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.
  */
-export declare function compute<T>(owner: Owner | null, compute: (val: T) => T, observer: Computation<T>): T;
-export declare function compute<T>(owner: Owner | null, compute: (val: undefined) => T, observer: null): 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 {};

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);
+    _onerror: ((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: (val?: T) => 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,10 @@ 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;
+}
+export declare class ProjectionComputation extends Computation {
+    _queue: IQueue;
+    constructor(compute: () => 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/flags.d.ts

@@ -5,4 +5,7 @@ export declare const ERROR: unique symbol;
 export declare const LOADING_OFFSET = 1;
 export declare const LOADING_BIT: number;
 export declare const LOADING: unique symbol;
+export declare const UNINITIALIZED_OFFSET = 2;
+export declare const UNINITIALIZED_BIT: number;
+export declare const UNINITIALIZED: unique symbol;
 export declare const DEFAULT_FLAGS: number;

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, isStale, latest, 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

@@ -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/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, isStale, latest, 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.7",
+  "version": "0.0.9",
   "description": "",
   "author": "Ryan Carniato",
   "license": "MIT",