@solidjs/signals 0.6.3 → 0.7.0

package/dist/types/boundaries.d.ts

@@ -6,7 +6,7 @@ export declare class CollectionQueue extends Queue {
     _disabled: Computation<boolean>;
     constructor(type: number);
     run(type: number): void;
-    notify(node: Effect, type: number, flags: number): any;
+    notify(node: Effect, type: number, flags: number): boolean;
     merge(queue: CollectionQueue): void;
 }
 export declare enum BoundaryMode {

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

@@ -77,6 +77,7 @@ export declare class Computation<T = any> extends Owner implements SourceType, O
     _forceNotify: boolean;
     _transition?: Transition | undefined;
     _cloned?: Computation;
+    _optimistic?: boolean;
     constructor(initialValue: T | undefined, compute: null | ((p?: T) => T), options?: SignalOptions<T>);
     _read(): T;
     /**
@@ -148,12 +149,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;
-/**
- * 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/effect.d.ts

@@ -24,6 +24,14 @@ export declare class Effect<T = any> extends Computation<T> {
     _disposeNode(): void;
     _run(type: number): void;
 }
+export declare class TrackedEffect extends Computation {
+    _type: number;
+    _cleanup: (() => void) | undefined;
+    constructor(compute: () => void | (() => void), options?: SignalOptions<undefined>);
+    _notify(state: number, skipQueue?: boolean): void;
+    _disposeNode(): void;
+    _run(type: number): void;
+}
 export declare class EagerComputation<T = any> extends Computation<T> {
     constructor(initialValue: T, compute: () => T, options?: SignalOptions<T> & {
         defer?: boolean;

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

@@ -1,6 +1,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 { Computation, getObserver, isEqual, untrack, hasUpdated, isPending, latest, UNCHANGED, compute, type SignalOptions } from "./core.js";
 export { Effect, EagerComputation } from "./effect.js";
 export { flush, Queue, incrementClock, transition, ActiveTransition, type IQueue } from "./scheduler.js";
 export * from "./constants.js";

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

@@ -79,7 +79,7 @@ export declare class Transition implements IQueue {
  * @description https://docs.solidjs.com/reference/advanced-reactivity/transition
  */
 export declare function transition(fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any> | Iterable<any>): void;
-export declare function cloneGraph(node: Computation): Computation;
+export declare function cloneGraph(node: Computation, optimistic?: boolean): Computation;
 export declare function getOGSource<T extends Computation>(input: T): T;
 export declare function getTransitionSource<T extends Computation>(input: T): T;
 export declare function getQueue(node: Computation): IQueue;

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, transition, 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, 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

@@ -1,6 +1,5 @@
 import type { SignalOptions } from "./core/index.js";
 import { Owner } from "./core/index.js";
-import { type Store, type StoreSetter } from "./store/index.js";
 export type Accessor<T> = () => T;
 export type Setter<in out T> = {
     <U extends T>(...args: undefined extends T ? [] : [value: Exclude<U, Function> | ((prev: T) => U)]): undefined extends T ? undefined : U;
@@ -124,6 +123,34 @@ export declare function createEffect<Next, Init = Next>(compute: ComputeFunction
  */
 export declare function createRenderEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>): void;
 export declare function createRenderEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
+/**
+ * Creates a tracked reactive effect that only tracks dependencies inside the effect itself
+ * ```typescript
+ * export function createTrackedEffect(
+ *   compute: () => (() => void) | void,
+ *   options?: { name?: string, defer?: boolean }
+ * ): void;
+ * ```
+ * @param compute a function that contains reactive reads to track and returns an optional cleanup function to run on disposal or before next execution
+ * @param options allows to set a name in dev mode for debugging purposes
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-tracked-effect
+ */
+export declare function createTrackedEffect(compute: () => void | (() => void), options?: EffectOptions): void;
+/**
+ * Creates a reactive computation that runs after the render phase with flexible tracking
+ * ```typescript
+ * export function createReaction(
+ *   onInvalidate: () => void,
+ *   options?: { name?: string }
+ * ): (fn: () => void) => void;
+ * ```
+ * @param invalidated a function that is called when tracked function is invalidated.
+ * @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: EffectFunction<undefined> | EffectBundle<undefined>, options?: EffectOptions): (tracking: () => void) => void;
 /**
  * Creates a new non-tracked reactive context with manual disposal
  *
@@ -147,6 +174,9 @@ export declare function runWithOwner<T>(owner: Owner | null, run: () => T): T;
  * @param fn a reactive expression to resolve
  */
 export declare function resolve<T>(fn: () => T): Promise<T>;
+export declare function createOptimistic<T>(): Signal<T | undefined>;
+export declare function createOptimistic<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
+export declare function createOptimistic<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
 /** Allows the user to mark a state change as non-urgent.
  *
  * @see {@link https://docs.solidjs.com/reference/advanced-reactivity/transition}
@@ -157,24 +187,3 @@ export declare function useTransition(): [
     get: Accessor<boolean>,
     start: (fn: (resume: (fn: () => any | Promise<any>) => void) => any | Promise<any> | Iterable<any>) => void
 ];
-/**
- * Creates an optimistic store that can be used to optimistically update a value
- * and then revert it back to the previous value at end of transition.
- * ```typescript
- * export function createOptimistic<T>(
- *   fn: (store: T) => void,
- *   initial: T,
- *   options?: { key?: string | ((item: NonNullable<any>) => any); all?: boolean }
- * ): [get: Store<T>, set: StoreSetter<T>];
- * ```
- * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
- * @param initial The initial value of the signal.
- * @param options Optional signal options.
- *
- * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
- */
-export declare function createOptimistic<T extends object = {}>(initial: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
-export declare function createOptimistic<T extends object = {}>(fn: (store: T) => void, initial: T | Store<T>, options?: {
-    key?: string | ((item: NonNullable<any>) => any);
-    all?: boolean;
-}): [get: Store<T>, set: StoreSetter<T>];

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

@@ -2,5 +2,6 @@ export type { Store, StoreSetter, StoreNode, NotWrappable, SolidStore } from "./
 export type { Merge, Omit } from "./utils.js";
 export { isWrappable, createStore, deep, $TRACK, $PROXY, $TARGET } from "./store.js";
 export { createProjection } from "./projection.js";
+export { createOptimisticStore } from "./optimistic.js";
 export { reconcile } from "./reconcile.js";
 export { snapshot, merge, omit } from "./utils.js";

package/dist/types/store/optimistic.d.ts

@@ -0,0 +1,22 @@
+import { type Store, type StoreSetter } from "./store.js";
+/**
+ * Creates an optimistic store that can be used to optimistically update a value
+ * and then revert it back to the previous value at end of transition.
+ * ```typescript
+ * export function createOptimistic<T>(
+ *   fn: (store: T) => void,
+ *   initial: T,
+ *   options?: { key?: string | ((item: NonNullable<any>) => any); all?: boolean }
+ * ): [get: Store<T>, set: StoreSetter<T>];
+ * ```
+ * @param fn a function that receives the current store and can be used to mutate it directly inside a transition
+ * @param initial The initial value of the signal.
+ * @param options Optional signal options.
+ *
+ * @returns A tuple containing an accessor for the current value and a setter function to apply changes.
+ */
+export declare function createOptimisticStore<T extends object = {}>(initial: T | Store<T>): [get: Store<T>, set: StoreSetter<T>];
+export declare function createOptimisticStore<T extends object = {}>(fn: (store: T) => T | void, initial: T | Store<T>, options?: {
+    key?: string | ((item: NonNullable<any>) => any);
+    all?: boolean;
+}): [get: Store<T>, set: StoreSetter<T>];

package/dist/types/store/projection.d.ts

@@ -1,7 +1,12 @@
+import { FirewallComputation } from "../core/effect.js";
 import { type Store, type StoreOptions } from "./store.js";
+export declare function createProjectionInternal<T extends object = {}>(fn: (draft: T) => void | T, initialValue?: T, options?: StoreOptions): {
+    store: Readonly<T>;
+    node: FirewallComputation;
+};
 /**
  * Creates a mutable derived value
  *
  * @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, initialValue?: T, options?: StoreOptions): Store<T>;

package/dist/types/store/store.d.ts

@@ -32,6 +32,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, store: T | Store<T>, options?: StoreOptions): [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 deep<T extends object>(store: Store<T>): Store<T>;
 export {};

package/package.json

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