@solidjs/signals 0.1.0 → 0.2.1

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

@@ -51,7 +51,7 @@ interface ObserverType {
 /**
  * Returns the current observer.
  */
-export declare function getObserver(): ObserverType | null;
+export declare function getObserver(): Computation | null;
 export declare const UNCHANGED: unique symbol;
 export type UNCHANGED = typeof UNCHANGED;
 export declare class Computation<T = any> extends Owner implements SourceType, ObserverType {
@@ -142,12 +142,20 @@ export declare function hasUpdated(fn: () => any): boolean;
 /**
  * Returns true if the given function contains async signals are out of date.
  */
-export declare function isStale(fn: () => any): boolean;
+export declare function isPending(fn: () => any): boolean;
+export declare function isPending(fn: () => any, loadingValue: boolean): boolean;
 /**
  * Attempts to resolve value of expression synchronously returning the last resolved value for any async computation.
  */
 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.
+ *
+ * Warning: Usually there are simpler ways of modeling a problem that avoid using this function
+ */
+export declare function runWithObserver<T>(observer: Computation, run: () => T): T | 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/index.d.ts

@@ -1,6 +1,6 @@
 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, isStale, latest, catchError, UNCHANGED, compute, type SignalOptions } from "./core.js";
+export { Computation, createBoundary, getObserver, isEqual, untrack, hasUpdated, isPending, latest, catchError, 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";

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, isStale, latest, 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, isPending, latest, catchError, runWithObserver, 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/dist/types/signals.d.ts

@@ -12,8 +12,10 @@ 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 interface EffectOptions {
     name?: string;
+    defer?: boolean;
 }
-export interface MemoOptions<T> extends EffectOptions {
+export interface MemoOptions<T> {
+    name?: string;
     equals?: false | ((prev: T, next: T) => boolean);
 }
 export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
@@ -95,7 +97,7 @@ 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, 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
@@ -125,11 +127,12 @@ export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFu
  */
 export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T)): T;
 /**
- * Runs the given function in the given owner so that error handling and cleanups continue to work.
+ * Runs the given function in the given owner to move ownership of nested primitives and cleanups.
+ * This method untracks the current scope.
  *
  * 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 | undefined;
+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
@@ -145,18 +148,3 @@ export declare function createErrorBoundary<T, U>(fn: () => T, fallback: (error:
  * @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/package.json

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