@solidjs/signals 0.4.1 → 0.4.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 Transition } from "./scheduler.js";
 export interface SignalOptions<T> {
     id?: string;
     name?: string;
@@ -35,14 +36,16 @@ export interface SignalOptions<T> {
     pureWrite?: boolean;
     unobserved?: () => void;
 }
-interface SourceType {
+export interface SourceType {
     _observers: ObserverType[] | null;
     _unobserved?: () => void;
     _updateIfNecessary: () => void;
+    _transition?: Transition;
+    _cloned?: Computation;
     _stateFlags: Flags;
     _time: number;
 }
-interface ObserverType {
+export interface ObserverType {
     _sources: SourceType[] | null;
     _notify: (state: number, skipQueue?: boolean) => void;
     _handlerMask: Flags;
@@ -71,6 +74,8 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
     _handlerMask: number;
     _time: number;
     _forceNotify: boolean;
+    _transition?: Transition | undefined;
+    _cloned?: Computation;
     constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
     _read(): T;
     /**
@@ -154,4 +159,3 @@ export declare function runWithObserver<T>(observer: Computation, run: () => 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

@@ -1,5 +1,6 @@
 import { EFFECT_RENDER, EFFECT_USER } from "./constants.js";
 import { Computation, type SignalOptions } from "./core.js";
+import { type Flags } from "./flags.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
@@ -18,6 +19,7 @@ export declare class Effect<T = any> extends Computation<T> {
     });
     write(value: T, flags?: number): T;
     _notify(state: number, skipQueue?: boolean): void;
+    _notifyFlags(mask: Flags, newFlags: Flags): void;
     _setError(error: unknown): void;
     _disposeNode(): void;
     _run(type: number): void;

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

@@ -2,6 +2,6 @@ export { ContextNotFoundError, NoOwnerError, NotReadyError } 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, runWithObserver, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
-export { flush, Queue, incrementClock, getClock, type IQueue } from "./scheduler.js";
+export { flush, Queue, incrementClock, transition, ActiveTransition, type IQueue } from "./scheduler.js";
 export * from "./constants.js";
 export * from "./flags.js";

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

@@ -1,6 +1,9 @@
-export declare function getClock(): number;
+import type { Computation, ObserverType } from "./core.js";
+import type { Effect } from "./effect.js";
+export declare let clock: number;
 export declare function incrementClock(): void;
-type QueueCallback = (type: number) => void;
+export declare let ActiveTransition: Transition | null;
+export type QueueCallback = (type: number) => void;
 export interface IQueue {
     enqueue(type: number, fn: QueueCallback): void;
     run(type: number): boolean | void;
@@ -30,4 +33,42 @@ export declare const globalQueue: Queue;
  * the queue synchronously to get the latest updates by calling `flush()`.
  */
 export declare function flush(): void;
-export {};
+export declare class Transition implements IQueue {
+    _sources: Map<Computation, Computation>;
+    _pendingNodes: Set<Effect>;
+    _promises: Set<Promise<any>>;
+    _optimistic: Set<(() => void) & {
+        _transition?: Transition;
+    }>;
+    _done: Transition | boolean;
+    _queues: [QueueCallback[], QueueCallback[]];
+    _pureQueue: QueueCallback[];
+    _children: IQueue[];
+    _parent: IQueue | null;
+    _running: boolean;
+    _scheduled: boolean;
+    created: number;
+    enqueue(type: number, fn: QueueCallback): void;
+    run(type: number): void;
+    flush(): void;
+    addChild(child: IQueue): void;
+    removeChild(child: IQueue): void;
+    notify(node: Effect, type: number, flags: number): boolean;
+    schedule(): void;
+    runTransition(fn: () => any | Promise<any>, force?: boolean): void;
+    addOptimistic(fn: (() => void) & {
+        _transition?: Transition;
+    }): void;
+}
+/**
+ * Runs the given function in a transition scope, allowing for batch updates and optimizations.
+ * This is useful for grouping multiple state updates together to avoid unnecessary re-renders.
+ *
+ * @param fn A function that receives a resume function to continue the transition.
+ * The resume function can be called with another function to continue the transition.
+ *
+ * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
+ */
+export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any>): void;
+export declare function cloneGraph(node: Computation): Computation;
+export declare function removeSourceObservers(node: ObserverType, index: number): void;

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, runWithObserver, SUPPORTS_PROXY } from "./core/index.js";
+export { Computation, ContextNotFoundError, NoOwnerError, NotReadyError, Owner, Queue, createContext, flush, getContext, setContext, hasContext, getOwner, onCleanup, getObserver, isEqual, untrack, hasUpdated, isPending, latest, runWithObserver, transition, SUPPORTS_PROXY } from "./core/index.js";
 export type { 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

@@ -159,16 +159,6 @@ export declare function resolve<T>(fn: () => T): Promise<T>;
 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>;
-/**
- * Runs the given function in a transition scope, allowing for batch updates and optimizations.
- * This is useful for grouping multiple state updates together to avoid unnecessary re-renders.
- *
- * @param fn A function that receives a resume function to continue the transition.
- * The resume function can be called with another function to continue the transition.
- *
- * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
- */
-export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any>): void;
 /**
  * Creates an optimistic signal that can be used to optimistically update a value
  * and then revert it back to the previous value at end of transition.
@@ -179,4 +169,5 @@ export declare function transition(fn: (resume: (fn: () => any | Promise<any>) =
  *
  * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
  */
-export declare function createOptimistic<T, U>(initial: T, compute?: (prev: T, change: U) => void, options?: SignalOptions<T>): [Accessor<T>, (v: U) => void];
+export declare function createOptimistic<T>(initial: Exclude<T, Function>, compute?: never): [Accessor<T>, (value: T | ((v?: T) => T)) => void];
+export declare function createOptimistic<T extends object, U>(initial: T | Accessor<T>, compute: (prev: T, change: U) => void, key: string | ((item: any) => any)): [Accessor<T>, (value: U | ((v?: U) => U)) => void];

package/package.json

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