global: snapshot

modules/solidjs-signals/0.9.2/dist/types/core/core.d.ts

@@ -16,6 +16,7 @@ export interface SignalOptions<T> {
     equals?: ((prev: T, next: T) => boolean) | false;
     pureWrite?: boolean;
     unobserved?: () => void;
+    lazy?: boolean;
 }
 export interface RawSignal<T> {
     id?: string;
@@ -64,6 +65,7 @@ export interface Computed<T> extends RawSignal<T>, Owner {
     _nextHeap: Computed<any> | undefined;
     _prevHeap: Computed<any>;
     _fn: (prev?: T) => T;
+    _inFlight: Promise<T> | AsyncIterable<T> | null;
     _child: FirewallSignal<any> | null;
     _notifyQueue?: (statusFlagsChanged: boolean, prevStatusFlags: number) => void;
 }
@@ -74,16 +76,11 @@ export interface Root extends Owner {
 }
 export declare let context: Owner | null;
 export declare function recompute(el: Computed<any>, create?: boolean): void;
+export declare function handleAsync<T>(el: Computed<T>, result: T | Promise<T> | AsyncIterable<T>, setter?: (value: T) => void): T;
 export declare function dispose(node: Computed<unknown>): void;
 export declare function getNextChildId(owner: Owner): string;
-export declare function computed<T>(fn: (prev?: T) => T): Computed<T>;
-export declare function computed<T>(fn: (prev: T) => T, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
-export declare function asyncComputed<T>(asyncFn: (prev?: T, refreshing?: boolean) => T | Promise<T> | AsyncIterable<T>): Computed<T> & {
-    _refresh: () => void;
-};
-export declare function asyncComputed<T>(asyncFn: (prev: T, refreshing?: boolean) => T | Promise<T> | AsyncIterable<T>, initialValue: T, options?: SignalOptions<T>): Computed<T> & {
-    _refresh: () => void;
-};
+export declare function computed<T>(fn: (prev?: T) => T | Promise<T> | AsyncIterable<T>): Computed<T>;
+export declare function computed<T>(fn: (prev: T) => T | Promise<T> | AsyncIterable<T>, initialValue?: T, options?: SignalOptions<T>): Computed<T>;
 export declare function signal<T>(v: T, options?: SignalOptions<T>): Signal<T>;
 export declare function signal<T>(v: T, options?: SignalOptions<T>, firewall?: Computed<any>): FirewallSignal<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
@@ -121,3 +118,5 @@ export declare function runWithOwner<T>(owner: Owner | null, fn: () => T): T;
 export declare function staleValues<T>(fn: () => T, set?: boolean): T;
 export declare function pending<T>(fn: () => T): T;
 export declare function isPending(fn: () => any): boolean;
+export declare function refresh<T>(fn: () => T): T;
+export declare function isRefreshing(): boolean;

modules/solidjs-signals/0.9.2/dist/types/core/index.d.ts

@@ -1,6 +1,6 @@
 export { ContextNotFoundError, NoOwnerError, NotReadyError } from "./error.js";
 export { createContext, getContext, setContext, type Context, type ContextRecord } from "./context.js";
-export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, dispose, signal, asyncComputed, read, setSignal, onCleanup, getNextChildId, isPending, pending, staleValues, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
+export { getObserver, isEqual, untrack, getOwner, runWithOwner, createOwner, createRoot, computed, dispose, signal, read, setSignal, onCleanup, getNextChildId, isPending, pending, refresh, isRefreshing, staleValues, handleAsync, type Owner, type Computed, type Root, type Signal, type SignalOptions } from "./core.js";
 export { effect, type Effect } from "./effect.js";
 export { flush, Queue, type IQueue, type QueueCallback } from "./scheduler.js";
 export * from "./constants.js";

modules/solidjs-signals/0.9.2/dist/types/core/scheduler.d.ts

@@ -1,5 +1,6 @@
 import type { Computed, Signal } from "./core.js";
 import { type Heap } from "./heap.js";
+export declare let optimisticRun: boolean;
 export declare const dirtyQueue: Heap;
 export declare const zombieQueue: Heap;
 export declare let clock: number;
@@ -13,7 +14,9 @@ export interface Transition {
     time: number;
     asyncNodes: Computed<any>[];
     pendingNodes: Signal<any>[];
+    optimisticNodes: Signal<any>[];
     queueStash: QueueStub;
+    done: boolean;
 }
 export declare function schedule(): void;
 export interface IQueue {
@@ -43,12 +46,15 @@ export declare class Queue implements IQueue {
 export declare class GlobalQueue extends Queue {
     _running: boolean;
     _pendingNodes: Signal<any>[];
+    _optimisticNodes: Signal<any>[];
     static _update: (el: Computed<unknown>) => void;
     static _dispose: (el: Computed<unknown>, self: boolean, zombie: boolean) => void;
     flush(): void;
     notify(node: Computed<any>, mask: number, flags: number): boolean;
     initTransition(node: Computed<any>): void;
 }
+export declare function notifySubs(node: Signal<any> | Computed<any>): void;
+export declare function runOptimistic(activeTransition?: Transition | null): void;
 export declare const globalQueue: GlobalQueue;
 /**
  * By default, changes are batched on the microtask queue which is an async process. You can flush

modules/solidjs-signals/0.9.2/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { ContextNotFoundError, NoOwnerError, NotReadyError, createContext, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, SUPPORTS_PROXY } from "./core/index.js";
+export { ContextNotFoundError, NoOwnerError, NotReadyError, createContext, createRoot, runWithOwner, flush, getNextChildId, getContext, setContext, getOwner, onCleanup, getObserver, isEqual, untrack, isPending, pending, isRefreshing, refresh, SUPPORTS_PROXY } from "./core/index.js";
 export type { Owner, SignalOptions, Context, ContextRecord, IQueue } from "./core/index.js";
 export * from "./signals.js";
 export { mapArray, repeat, type Maybe } from "./map.js";

modules/solidjs-signals/0.9.2/dist/types/signals.d.ts

@@ -7,7 +7,7 @@ export type Setter<in out T> = {
     <U extends T>(value: Exclude<U, Function> | ((prev: T) => U)): U;
 };
 export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
-export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Next;
+export type ComputeFunction<Prev, Next extends Prev = Prev> = (v: Prev) => Promise<Next> | AsyncIterable<Next> | Next;
 export type EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
 export type EffectBundle<Prev, Next extends Prev = Prev> = {
     effect: EffectFunction<Prev, Next>;
@@ -65,24 +65,6 @@ export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T
  */
 export declare function createMemo<Next extends Prev, Prev = Next>(compute: ComputeFunction<undefined | NoInfer<Prev>, Next>): Accessor<Next>;
 export declare function createMemo<Next extends Prev, Init = Next, Prev = Next>(compute: ComputeFunction<Init | Prev, Next>, value: Init, options?: MemoOptions<Next>): Accessor<Next>;
-/**
- * Creates a readonly derived async reactive memoized signal
- * ```typescript
- * export function createAsync<T>(
- *   compute: (v: T) => Promise<T> | T,
- *   value?: T,
- *   options?: { name?: string, equals?: false | ((prev: T, next: T) => boolean) }
- * ): () => T;
- * ```
- * @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 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 and use a custom comparison function in equals
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-async
- */
-export declare function createAsync<T>(compute: (prev: T | undefined, refreshing: boolean) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T> & {
-    refresh: () => void;
-};
 /**
  * Creates a reactive effect that runs after the render phase
  * ```typescript

modules/solidjs-signals/0.9.2/dist/types/store/projection.d.ts

@@ -1,5 +1,5 @@
 import { type Store, type StoreOptions } from "./store.js";
-export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T, initialValue?: T, options?: StoreOptions): {
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: StoreOptions): {
     store: Readonly<T>;
     node: any;
 };
@@ -8,4 +8,4 @@ export declare function createProjectionInternal<T extends object = {}>(fn: (dra
  *
  * @see {@link https://github.com/solidjs/x-reactivity#createprojection}
  */
-export declare function createProjection<T extends Object = {}>(fn: (draft: T) => void | T, initialValue?: T, options?: StoreOptions): Store<T>;
+export declare function createProjection<T extends Object = {}>(fn: (draft: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, initialValue?: T, options?: StoreOptions): Store<T>;

modules/solidjs-signals/0.9.2/dist/types/store/store.d.ts

@@ -33,6 +33,6 @@ export declare function getPropertyDescriptor(source: Record<PropertyKey, any>,
 export declare const storeTraps: ProxyHandler<StoreNode>;
 export declare function storeSetter<T extends object>(store: Store<T>, fn: (draft: T) => T | void): void;
 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 | T, store: T | Store<T>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
+export declare function createStore<T extends object = {}>(fn: (store: T) => void | T | Promise<void | T> | AsyncIterable<void | T>, store: T | Store<T>, options?: StoreOptions): [get: Store<T>, set: StoreSetter<T>];
 export declare function deep<T extends object>(store: Store<T>): Store<T>;
 export {};