@solidjs/signals 0.2.5 → 0.3.1

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

@@ -0,0 +1,17 @@
+import { Computation } from "./core.js";
+import { type Effect } from "./effect.js";
+import { Queue } from "./scheduler.js";
+export declare class CollectionQueue extends Queue {
+    _collectionType: number;
+    _nodes: Set<Effect>;
+    _disabled: Computation<boolean>;
+    constructor(type: number);
+    notify(node: Effect, type: number, flags: number): boolean;
+}
+export declare enum BoundaryMode {
+    VISIBLE = "visible",
+    HIDDEN = "hidden"
+}
+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;

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

@@ -28,7 +28,6 @@
  */
 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;
@@ -67,7 +66,6 @@ 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;
-    _loading: Computation<boolean> | null;
     _time: number;
     _forceNotify: boolean;
     constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
@@ -85,14 +83,6 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
      * before continuing
      */
     wait(): T;
-    /**
-     * Return true if the computation is the value is dependent on an unresolved promise
-     * Triggers re-execution of the computation when the loading state changes
-     *
-     * This is useful especially when effects want to re-execute when a computation's
-     * loading state changes
-     */
-    loading(): boolean;
     /** Update the computation with a new value. */
     write(value: T | ((currentValue: T) => T) | UNCHANGED, flags?: number, raw?: boolean): T;
     /**
@@ -140,7 +130,7 @@ export declare function untrack<T>(fn: () => T): T;
  */
 export declare function hasUpdated(fn: () => any): boolean;
 /**
- * Returns 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 are out of date.
  */
 export declare function isPending(fn: () => any): boolean;
 export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
@@ -149,7 +139,6 @@ export declare function isPending(fn: () => any, loadingValue: boolean): boolean
  */
 export declare function latest<T>(fn: () => T): T;
 export declare function latest<T, U>(fn: () => T, fallback: U): T | U;
-export declare function catchError(fn: () => void): unknown | undefined;
 /**
  * Runs the given function in the given observer.
  *
@@ -166,5 +155,4 @@ export declare function flatten(children: any, options?: {
     skipNonRendered?: boolean;
     doNotUnwrap?: boolean;
 }): any;
-export declare function createBoundary<T>(fn: () => T, queue: IQueue): T;
 export {};

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

@@ -1,8 +1,9 @@
 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, createBoundary, getObserver, isEqual, untrack, hasUpdated, isPending, latest, flatten, catchError, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
+export { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, flatten, UNCHANGED, compute, runWithObserver, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
-export { flushSync, getClock, incrementClock, type IQueue, Queue } from "./scheduler.js";
-export { createSuspense } from "./suspense.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 * from "./flags.js";

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

@@ -27,7 +27,6 @@
  *
  * 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";
 export type ContextRecord = Record<string | symbol, unknown>;
 export interface Disposable {
@@ -45,14 +44,15 @@ export declare class Owner {
     _state: number;
     _disposal: Disposable | Disposable[] | null;
     _context: ContextRecord;
-    _handlers: ErrorHandler[] | null;
     _queue: IQueue;
-    constructor(signal?: boolean);
+    _childCount: number;
+    id: string | null;
+    constructor(id?: string | null, skipAppend?: boolean);
     append(child: Owner): void;
     dispose(this: Owner, self?: boolean): void;
     _disposeNode(): void;
     emptyDisposal(): void;
-    handleError(error: unknown): void;
+    getNextChildId(): string;
 }
 export interface Context<T> {
     readonly id: symbol;

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

@@ -9,17 +9,21 @@ export interface IQueue {
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
     created: number;
+    notify(...args: any[]): boolean;
+    _parent: IQueue | null;
 }
 export declare class Queue implements IQueue {
+    _parent: IQueue | null;
     _running: boolean;
     _queues: [Computation[], Effect[], Effect[]];
     _children: IQueue[];
     created: number;
     enqueue<T extends Computation | Effect>(type: number, node: T): void;
-    run(type: number): true | undefined;
+    run(type: number): boolean | undefined;
     flush(): void;
     addChild(child: IQueue): void;
     removeChild(child: IQueue): void;
+    notify(...args: any[]): boolean;
 }
 export declare const globalQueue: Queue;
 /**

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

@@ -1 +1,4 @@
 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>;

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, catchError, runWithObserver, createSuspense, SUPPORTS_PROXY } from "./core/index.js";
-export type { ErrorHandler, SignalOptions, Context, ContextRecord, Disposable, IQueue } from "./core/index.js";
+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 { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./signals.js";
 export * from "./store/index.js";

package/dist/types/signals.d.ts

@@ -125,7 +125,9 @@ export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFu
  *
  * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
  */
-export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T)): T;
+export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T), options?: {
+    id: string;
+}): T;
 /**
  * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
  * This method untracks the current scope.
@@ -133,16 +135,6 @@ export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() =
  * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
  */
 export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;
-/**
- * Switches to fallback whenever an error is thrown within the context of the child scopes
- * @param fn boundary for the error
- * @param fallback an error handler that receives the error
- *
- * * If the error is thrown again inside the error handler, it will trigger the next available parent handler
- *
- * @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

package/package.json

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

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

@@ -1,11 +0,0 @@
-import { Computation } from "./core.js";
-import { type Effect } from "./effect.js";
-import { Queue } from "./scheduler.js";
-export declare class SuspenseQueue extends Queue {
-    _nodes: Set<Effect>;
-    _fallback: boolean;
-    _signal: Computation<boolean>;
-    run(type: number): true | undefined;
-    _update(node: Effect): void;
-}
-export declare function createSuspense(fn: () => any, fallback: () => any): () => any;