@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.18

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

@@ -219,3 +219,8 @@ export declare const $REFRESH: unique symbol;
 export type Refreshable<T> = T & {
     readonly [$REFRESH]: any;
 };
+/** `Set` under a module binding. Bundlers mark a bare `new Set()` pure with
+ * a `/* @__PURE__ *\/` comment that survives minification (16 bytes a site);
+ * a construction through a binding carries none. Same constructor, so the
+ * same objects. */
+export declare const NewSet: SetConstructor;

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

@@ -68,13 +68,13 @@ export declare function createEffectNode<T>(fn: (prev?: T) => T, effectFn: (val:
  * channel (`_x._notifyStatus`) went with them; effects are the only
  * display consumers.
  */
-export declare let effectStatusNotify: ((this: any, status?: number, error?: any) => void) | null;
+export declare let effectStatusNotify: ((this: any) => void) | null;
 export declare function setEffectStatusNotify(fn: NonNullable<typeof effectStatusNotify>): void;
 /** Resolve a node's status notifier: effect nodes (`_type` — EFFECT_PURE is
  * 0, and only effect literals carry the field) get the shared notifier.
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */
-export declare function statusNotifierOf(el: any): ((this: any, status?: number, error?: any) => void) | undefined;
+export declare function statusNotifierOf(el: any): ((this: any) => void) | null;
 export declare function signal<T>(v: T, options?: NodeOptions<T>): Signal<T>;
 export declare function isEqual<T>(a: T, b: T): boolean;
 /** A store slot node (CONFIG_SLOT_NODE): the whole node in ONE literal — the
@@ -128,7 +128,23 @@ export declare let disposalDepth: number;
 export declare function enterDisposal(): void;
 export declare function exitDisposal(): void;
 export declare function resetDisposalDepth(): void;
-export declare function setStrictRead(v: string | false): string | false;
+/**
+ * Dev-only: the DOM event being dispatched when the open strict-read window
+ * opened (`globalThis.event`; null between dispatches and off the main
+ * thread's Window), or `ANY_EVENT` when the window did not record one. A DOM
+ * call made in an effect callback that dispatches events synchronously
+ * (`el.focus()`, `el.click()`, `dialog.showModal()`) runs that event's
+ * handlers inside the window; a handler is a one-shot snapshot whoever
+ * dispatched the event, so a read made while a different event is current is
+ * outside the window (#4235). Only queued effect runs record the event, read
+ * once per queue (the getter is costly under jsdom); `strictReadActive` is
+ * the check.
+ */
+export declare let strictReadEvent: unknown;
+export declare const dispatchingEvent: () => unknown;
+export declare function setStrictRead(v: string | false, event?: unknown): string | false;
+/** Dev-only: is the strict-read window open for a read made now? */
+export declare function strictReadActive(): boolean;
 /**
  * Runs `fn` outside of any reactive tracking — reads inside `fn` will not
  * subscribe the current scope. Returns whatever `fn` returns.

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

@@ -212,7 +212,14 @@ export declare function setQuestion(q: number): void;
 export declare function nextQuestion(): number;
 export declare const MAINLINE_QUESTION = 2147483647;
 export declare let inEffectCallback: boolean;
-export declare function setEffectCallback(value: boolean): void;
+/** Dev-only: matches no event, so a window or phase holding it applies
+ * whatever event is current (see `strictReadEvent`, core.ts). */
+export declare const ANY_EVENT: {};
+/** Dev-only: the DOM event current when the effect phase was entered. A
+ * handler dispatched synchronously from that phase (`el.focus()`) runs under
+ * a different event and is not in it (#4235). */
+export declare let effectCallbackEvent: unknown;
+export declare function setEffectCallback(value: boolean, event?: unknown): void;
 export type QueueCallback = (type: number) => void;
 export declare function schedule(): void;
 /**
@@ -313,8 +320,8 @@ export declare class GlobalQueue implements IQueue {
  * or without the held read) owes nothing. A run this transaction stashed
  * for it is void (#3322: an effect has one value slot, and the stale pass
  * overwrote the value that run was for) — the re-derivation's run replaces
- * it. */
-export declare function reruns(u: Transaction): void;
+ * it. Truthy when an effect re-derives (`land`). */
+export declare function reruns(u: Transaction): unknown;
 /** The held runs join this flush's effect phase after its own runs (the
  * landing's re-passes, in height order): the frame's effects run as one
  * pass would have queued them — a shell re-derived at the landing before a
@@ -383,3 +390,8 @@ export declare const globalQueue: GlobalQueue;
  */
 export declare function flush(): void;
 export declare function flush<T>(fn: () => T): T;
+/** Dev-only: the DOM event current when the running effect queue started,
+ * or `ANY_EVENT` outside one. Read once per queue rather than once per
+ * effect (the getter is costly under jsdom); no event starts or ends between
+ * two effects of one synchronous queue (#4235). */
+export declare let queueEvent: unknown;

package/dist/types/from.d.ts

@@ -0,0 +1,47 @@
+/** The observer a `subscribe` call receives. */
+type FromObserver<T> = {
+    next(value: T): void;
+    error(err: unknown): void;
+    complete(): void;
+};
+type Teardown = (() => void) | {
+    unsubscribe(): void;
+} | void;
+/**
+ * Anything `from` accepts: a subscribe function
+ * (`(next, error, complete) => unsubscribe`), an object with
+ * `subscribe(observer)` (RxJS and TC39 Observables, including
+ * `Symbol.observable` / `"@@observable"` interop), or an AsyncIterable.
+ */
+export type FromSource<T> = ((next: (value: T) => void, error: (err: unknown) => void, complete: () => void) => Teardown) | {
+    subscribe(observer: FromObserver<T>): Teardown;
+} | AsyncIterable<T>;
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */
+export declare function from<T>(source: FromSource<T>): AsyncIterable<T>;
+export {};

package/dist/types/index.d.ts

@@ -26,6 +26,7 @@ export { mapArray, repeat, type Maybe } from "./map.js";
 export * from "./store/index.js";
 export { affects } from "./affects.js";
 export { createDeferred } from "./deferred.js";
+export { from, type FromSource } from "./from.js";
 export { flatten } from "./flatten.js";
 export { createLoadingBoundary, createErrorBoundary } from "./boundaries.js";
 export { createRevealOrder, type RevealOrder } from "./reveal.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-rc.17",
+  "version": "2.0.0-rc.18",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",