@solidjs/signals 0.6.4 → 0.7.0

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

@@ -149,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/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

@@ -123,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
  *
@@ -146,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}

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

@@ -2,6 +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 { createOptimistic } from "./optimistic.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

@@ -15,8 +15,8 @@ import { type Store, type StoreSetter } from "./store.js";
  *
  * @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) => T | void, initial: T | Store<T>, options?: {
+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/package.json

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