@solidjs/signals 0.0.8 → 0.0.10

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

@@ -28,6 +28,7 @@
  */
 import { type Flags } from "./flags.js";
 import { Owner } from "./owner.js";
+import { type IQueue } from "./scheduler.js";
 export interface SignalOptions<T> {
     name?: string;
     equals?: ((prev: T, next: T) => boolean) | false;
@@ -51,14 +52,13 @@ 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;
 export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
     _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);
@@ -140,22 +140,19 @@ 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 isPending(fn: () => any): boolean;
-export type PossiblyResolved<T> = T extends Object ? RecursivePartial<T> : T;
-export type RecursivePartial<T> = {
-    [P in keyof T]?: PossiblyResolved<T[P]>;
-};
+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 resolveSync<T>(fn: () => T): PossiblyResolved<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 declare function createBoundary<T>(fn: () => T, queue: IQueue): T;
 export {};

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

@@ -1,6 +1,5 @@
 import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
 import { Computation, type SignalOptions } from "./core.js";
-import { type IQueue } from "./scheduler.js";
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
  * automatically added to the queue of effects to re-execute, which will cause them to fetch their
@@ -8,13 +7,12 @@ import { type IQueue } from "./scheduler.js";
  */
 export declare class Effect<T = any> extends Computation<T> {
     _effect: (val: T, prev: T | undefined) => void | (() => void);
-    _error: ((err: unknown) => void | (() => void)) | undefined;
+    _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 | (() => void), error?: (err: unknown) => void | (() => 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;
     });
@@ -25,7 +23,12 @@ export declare class Effect<T = any> extends Computation<T> {
     _runEffect(): void;
 }
 export declare class EagerComputation<T = any> extends Computation<T> {
-    _queue: IQueue;
-    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T>);
+    constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
+        defer?: boolean;
+    });
+    _notify(state: number, skipQueue?: boolean): void;
+}
+export declare class ProjectionComputation extends Computation {
+    constructor(compute: () => void);
     _notify(state: number, skipQueue?: boolean): void;
 }

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

@@ -1,3 +1,4 @@
+import type { Owner } from "./owner.js";
 export declare class NotReadyError extends Error {
 }
 export declare class NoOwnerError extends Error {
@@ -10,5 +11,5 @@ export declare class EffectError extends Error {
     constructor(effect: Function, cause: unknown);
 }
 export interface ErrorHandler {
-    (error: unknown): void;
+    (error: unknown, node: Owner): 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, getClock, hasUpdated, isPending, resolveSync, catchError, UNCHANGED, compute, type SignalOptions } from "./core.js";
+export { Computation, createBoundary, getObserver, isEqual, untrack, hasUpdated, isStale, latest, catchError, UNCHANGED, compute, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
-export { flushSync, createBoundary, type IQueue, Queue } from "./scheduler.js";
+export { flushSync, getClock, incrementClock, 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/owner.d.ts

@@ -28,7 +28,7 @@
  * Note that the owner tree is largely orthogonal to the reactivity tree, and is much closer to the component tree.
  */
 import { type ErrorHandler } from "./error.js";
-import type { IQueue } from "./scheduler.js";
+import { type IQueue } from "./scheduler.js";
 export type ContextRecord = Record<string | symbol, unknown>;
 export interface Disposable {
     (): void;
@@ -46,7 +46,7 @@ export declare class Owner {
     _disposal: Disposable | Disposable[] | null;
     _context: ContextRecord;
     _handlers: ErrorHandler[] | null;
-    _queue: IQueue | null;
+    _queue: IQueue;
     constructor(signal?: boolean);
     append(child: Owner): void;
     dispose(this: Owner, self?: boolean): void;

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

@@ -1,5 +1,7 @@
-import { Computation } from "./core.js";
+import type { Computation } from "./core.js";
 import type { Effect } from "./effect.js";
+export declare function getClock(): number;
+export declare function incrementClock(): void;
 export interface IQueue {
     enqueue<T extends Computation | Effect>(type: number, node: T): void;
     run(type: number): boolean | void;
@@ -23,4 +25,3 @@ export declare const globalQueue: Queue;
  * the queue synchronously to get the latest updates by calling `flushSync()`.
  */
 export declare function flushSync(): void;
-export declare function createBoundary<T>(fn: () => T, queue: IQueue): T;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-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 { 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, repeat, type Maybe } from "./map.js";
 export * from "./signals.js";

package/package.json

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