@solidjs/signals 0.0.3 → 0.0.4

package/dist/prod.js

@@ -25,7 +25,8 @@ function isUndefined(value) {
 var STATE_CLEAN = 0;
 var STATE_CHECK = 1;
 var STATE_DIRTY = 2;
-var STATE_DISPOSED = 3;
+var STATE_UNINITIALIZED = 3;
+var STATE_DISPOSED = 4;
 var EFFECT_PURE = 0;
 var EFFECT_RENDER = 1;
 var EFFECT_USER = 2;
@@ -46,9 +47,9 @@ var Owner = class {
   // We flatten the owner tree into a linked list so that we don't need a pointer to .firstChild
   // However, the children are actually added in reverse creation order
   // See comment at the top of the file for an example of the _nextSibling traversal
-  r = null;
-  m = null;
   o = null;
+  m = null;
+  p = null;
   a = STATE_CLEAN;
   h = null;
   n = defaultContext;
@@ -59,10 +60,10 @@ var Owner = class {
       currentOwner.append(this);
   }
   append(child) {
-    child.r = this;
     child.o = this;
+    child.p = this;
     if (this.m)
-      this.m.o = child;
+      this.m.p = child;
     child.m = this.m;
     this.m = child;
     if (child.n !== this.n) {
@@ -77,8 +78,8 @@ var Owner = class {
   dispose(self = true) {
     if (this.a === STATE_DISPOSED)
       return;
-    let head = self ? this.o || this.r : this, current = this.m, next = null;
-    while (current && current.r === this) {
+    let head = self ? this.p || this.o : this, current = this.m, next = null;
+    while (current && current.o === this) {
       current.dispose(true);
       current.x();
       next = current.m;
@@ -88,15 +89,15 @@ var Owner = class {
     if (self)
       this.x();
     if (current)
-      current.o = !self ? this : this.o;
+      current.p = !self ? this : this.p;
     if (head)
       head.m = current;
   }
   x() {
-    if (this.o)
-      this.o.m = null;
-    this.r = null;
+    if (this.p)
+      this.p.m = null;
     this.o = null;
+    this.p = null;
     this.n = defaultContext;
     this.i = null;
     this.a = STATE_DISPOSED;
@@ -156,17 +157,18 @@ function setContext(context, value, owner = currentOwner) {
 function hasContext(context, owner = currentOwner) {
   return !isUndefined(owner?.n[context.id]);
 }
-function onCleanup(disposable) {
+function onCleanup(fn) {
   if (!currentOwner)
-    return;
+    return fn;
   const node = currentOwner;
   if (!node.h) {
-    node.h = disposable;
+    node.h = fn;
   } else if (Array.isArray(node.h)) {
-    node.h.push(disposable);
+    node.h.push(fn);
   } else {
-    node.h = [node.h, disposable];
+    node.h = [node.h, fn];
   }
+  return fn;
 }
 
 // src/core/flags.ts
@@ -196,32 +198,32 @@ var Computation = class extends Owner {
   b = null;
   c = null;
   d;
-  D;
+  E;
   // Used in __DEV__ mode, hopefully removed in production
   V;
   // Using false is an optimization as an alternative to _equals: () => false
   // which could enable more efficient DIRTY notification
-  E = isEqual;
+  F = isEqual;
   N;
   /** Whether the computation is an error or has ancestors that are unresolved */
   j = 0;
   /** Which flags raised by sources are handled, vs. being passed through. */
   A = DEFAULT_FLAGS;
-  F = null;
   G = null;
-  H = -1;
+  H = null;
+  I = -1;
   constructor(initialValue, compute2, options) {
     super(compute2 === null);
-    this.D = compute2;
-    this.a = compute2 ? STATE_DIRTY : STATE_CLEAN;
+    this.E = compute2;
+    this.a = compute2 ? STATE_UNINITIALIZED : STATE_CLEAN;
     this.d = initialValue;
     if (options?.equals !== void 0)
-      this.E = options.equals;
+      this.F = options.equals;
     if (options?.unobserved)
       this.N = options?.unobserved;
   }
   O() {
-    if (this.D)
+    if (this.E)
       this.s();
     if (!this.b || this.b.length)
       track(this);
@@ -260,30 +262,30 @@ var Computation = class extends Owner {
    * loading state changes
    */
   loading() {
-    if (this.G === null) {
-      this.G = loadingState(this);
+    if (this.H === null) {
+      this.H = loadingState(this);
     }
-    return this.G.read();
+    return this.H.read();
   }
   /**
    * Return true if the computation is the computation threw an error
    * Triggers re-execution of the computation when the error state changes
    */
   error() {
-    if (this.F === null) {
-      this.F = errorState(this);
+    if (this.G === null) {
+      this.G = errorState(this);
     }
-    return this.F.read();
+    return this.G.read();
   }
   /** Update the computation with a new value. */
   write(value, flags = 0, raw = false) {
     const newValue = !raw && typeof value === "function" ? value(this.d) : value;
-    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.E === false || !this.E(this.d, newValue));
+    const valueChanged = newValue !== UNCHANGED && (!!(flags & ERROR_BIT) || this.a === STATE_UNINITIALIZED || this.F === false || !this.F(this.d, newValue));
     if (valueChanged)
       this.d = newValue;
     const changedFlagsMask = this.j ^ flags, changedFlags = changedFlagsMask & flags;
     this.j = flags;
-    this.H = clock + 1;
+    this.I = clock + 1;
     if (this.c) {
       for (let i = 0; i < this.c.length; i++) {
         if (valueChanged) {
@@ -363,7 +365,7 @@ var Computation = class extends Owner {
         }
       }
     }
-    if (this.a === STATE_DIRTY) {
+    if (this.a === STATE_DIRTY || this.a === STATE_UNINITIALIZED) {
       update(this);
     } else {
       this.write(UNCHANGED, observerFlags);
@@ -382,7 +384,7 @@ var Computation = class extends Owner {
   }
 };
 function loadingState(node) {
-  const prevOwner = setOwner(node.r);
+  const prevOwner = setOwner(node.o);
   const options = void 0;
   const computation = new Computation(
     void 0,
@@ -398,7 +400,7 @@ function loadingState(node) {
   return computation;
 }
 function errorState(node) {
-  const prevOwner = setOwner(node.r);
+  const prevOwner = setOwner(node.o);
   const options = void 0;
   const computation = new Computation(
     void 0,
@@ -423,7 +425,7 @@ function track(computation) {
       newSources.push(computation);
     }
     if (updateCheck) {
-      updateCheck.d = computation.H > currentObserver.H;
+      updateCheck.d = computation.I > currentObserver.I;
     }
   }
 }
@@ -435,7 +437,7 @@ function update(node) {
   try {
     node.dispose(false);
     node.emptyDisposal();
-    const result = compute(node, node.D, node);
+    const result = compute(node, node.E, node);
     node.write(result, newFlags, true);
   } catch (error) {
     if (error instanceof NotReadyError) {
@@ -543,10 +545,11 @@ function schedule() {
   if (scheduled)
     return;
   scheduled = true;
-  queueMicrotask(flushSync);
+  if (!globalQueue.B)
+    queueMicrotask(flushSync);
 }
 var Queue = class {
-  I = false;
+  B = false;
   u = [[], [], []];
   z = [];
   enqueue(type, node) {
@@ -571,16 +574,17 @@ var Queue = class {
     }
   }
   flush() {
-    if (this.I)
+    if (this.B)
       return;
-    this.I = true;
+    this.B = true;
     try {
       this.run(EFFECT_PURE);
       incrementClock();
+      scheduled = false;
       this.run(EFFECT_RENDER);
       this.run(EFFECT_USER);
     } finally {
-      this.I = false;
+      this.B = false;
     }
   }
   addChild(child) {
@@ -594,8 +598,9 @@ var Queue = class {
 };
 var globalQueue = new Queue();
 function flushSync() {
-  globalQueue.flush();
-  scheduled = false;
+  while (scheduled) {
+    globalQueue.flush();
+  }
 }
 function createBoundary(fn, queue) {
   const owner = new Owner();
@@ -606,7 +611,7 @@ function createBoundary(fn, queue) {
 }
 function runTop(node) {
   const ancestors = [];
-  for (let current = node; current !== null; current = current.r) {
+  for (let current = node; current !== null; current = current.o) {
     if (current.a !== STATE_CLEAN) {
       ancestors.push(current);
     }
@@ -631,17 +636,17 @@ function runEffectQueue(queue) {
 var Effect = class extends Computation {
   J;
   K = false;
-  B;
   C;
+  D;
   e;
   constructor(initialValue, compute2, effect, options) {
     super(initialValue, compute2, options);
     this.J = effect;
-    this.B = initialValue;
-    this.C = options?.render ? EFFECT_RENDER : EFFECT_USER;
+    this.C = initialValue;
+    this.D = options?.render ? EFFECT_RENDER : EFFECT_USER;
     this.e = getOwner()?.e || globalQueue;
     this.s();
-    this.C === EFFECT_USER ? this.e.enqueue(this.C, this) : this.R();
+    this.D === EFFECT_USER ? this.e.enqueue(this.D, this) : this.R();
   }
   write(value, flags = 0) {
     const currentFlags = this.j;
@@ -659,7 +664,7 @@ var Effect = class extends Computation {
     if (this.a >= state)
       return;
     if (this.a === STATE_CLEAN)
-      this.e.enqueue(this.C, this);
+      this.e.enqueue(this.D, this);
     this.a = state;
   }
   Q(error) {
@@ -667,13 +672,13 @@ var Effect = class extends Computation {
   }
   x() {
     this.J = void 0;
-    this.B = void 0;
+    this.C = void 0;
     super.x();
   }
   R() {
     if (this.K && this.a !== STATE_DISPOSED) {
-      this.J(this.d, this.B);
-      this.B = this.d;
+      this.J(this.d, this.C);
+      this.C = this.d;
       this.K = false;
     }
   }
@@ -697,24 +702,24 @@ var EagerComputation = class extends Computation {
 // src/core/suspense.ts
 var SuspenseQueue = class extends Queue {
   f = /* @__PURE__ */ new Set();
-  p = false;
+  q = false;
   L = new Computation(false, null);
   run(type) {
-    if (type && this.p)
+    if (type && this.q)
       return;
     super.run(type);
   }
   T(node) {
     if (node.j & LOADING_BIT) {
       this.f.add(node);
-      if (!this.p) {
-        this.p = true;
+      if (!this.q) {
+        this.q = true;
         queueMicrotask(() => this.L.write(true));
       }
     } else {
       this.f.delete(node);
       if (this.f.size === 0) {
-        this.p = false;
+        this.q = false;
         queueMicrotask(() => this.L.write(false));
       }
     }
@@ -723,7 +728,7 @@ var SuspenseQueue = class extends Queue {
 function createSuspense(fn, fallbackFn) {
   const queue = new SuspenseQueue();
   const tree = createBoundary(fn, queue);
-  const equality = new Computation(null, () => queue.L.read() || queue.p);
+  const equality = new Computation(null, () => queue.L.read() || queue.q);
   const comp = new Computation(null, () => equality.read() ? untrack(fallbackFn) : tree);
   return comp.read.bind(comp);
 }
@@ -744,14 +749,35 @@ function createSignal(first, second, third) {
   const node = new Computation(first, null, second);
   return [node.read.bind(node), node.write.bind(node)];
 }
-function createAsync(fn, initial, options) {
+function createMemo(compute2, value, options) {
+  let node = new Computation(
+    value,
+    compute2,
+    options
+  );
+  let resolvedValue;
+  return () => {
+    if (node) {
+      resolvedValue = node.wait();
+      if (!node.b?.length) {
+        node.dispose();
+        node = void 0;
+      } else if (!node.o && !node.c?.length) {
+        node.dispose();
+        node.a = STATE_UNINITIALIZED;
+      }
+    }
+    return resolvedValue;
+  };
+}
+function createAsync(compute2, value, options) {
   const lhs = new EagerComputation(
     {
-      d: initial
+      d: value
     },
     (p) => {
-      const value = p?.d;
-      const source = fn(value);
+      const value2 = p?.d;
+      const source = compute2(value2);
       const isPromise = source instanceof Promise;
       const iterator = source[Symbol.asyncIterator];
       if (!isPromise && !iterator) {
@@ -762,12 +788,12 @@ function createAsync(fn, initial, options) {
           d: source
         };
       }
-      const signal = new Computation(value, null, options);
+      const signal = new Computation(value2, null, options);
       signal.write(UNCHANGED, LOADING_BIT);
       if (isPromise) {
         source.then(
-          (value2) => {
-            signal.write(value2, 0);
+          (value3) => {
+            signal.write(value3, 0);
           },
           (error) => {
             signal.write(error, ERROR_BIT);
@@ -778,10 +804,10 @@ function createAsync(fn, initial, options) {
         onCleanup(() => abort = true);
         (async () => {
           try {
-            for await (let value2 of source) {
+            for await (let value3 of source) {
               if (abort)
                 return;
-              signal.write(value2, 0);
+              signal.write(value3, 0);
             }
           } catch (error) {
             signal.write(error, ERROR_BIT);
@@ -793,28 +819,16 @@ function createAsync(fn, initial, options) {
   );
   return () => lhs.wait().wait();
 }
-function createMemo(compute2, initialValue, options) {
-  let node = new Computation(initialValue, compute2, options);
-  let value;
-  return () => {
-    if (node) {
-      value = node.wait();
-      if (!node.b?.length)
-        node = void 0;
-    }
-    return value;
-  };
-}
-function createEffect(compute2, effect, initialValue, options) {
+function createEffect(compute2, effect, value, options) {
   void new Effect(
-    initialValue,
+    value,
     compute2,
     effect,
     void 0
   );
 }
-function createRenderEffect(compute2, effect, initialValue, options) {
-  void new Effect(initialValue, compute2, effect, {
+function createRenderEffect(compute2, effect, value, options) {
+  void new Effect(value, compute2, effect, {
     render: true,
     ...void 0
   });
@@ -1303,14 +1317,14 @@ function mapArray(list, map, options) {
     S: new Owner(),
     w: 0,
     U: list,
-    q: [],
+    r: [],
     M: map,
     k: [],
     f: [],
     y: keyFn,
     g: keyFn || options?.keyed === false ? [] : void 0,
     l: map.length > 1 ? [] : void 0,
-    p: options?.fallback
+    q: options?.fallback
   });
 }
 function updateKeyedMap() {
@@ -1336,31 +1350,35 @@ function updateKeyedMap() {
       if (this.w !== 0) {
         this.S.dispose(false);
         this.f = [];
-        this.q = [];
+        this.r = [];
         this.k = [];
         this.w = 0;
         this.g && (this.g = []);
         this.l && (this.l = []);
       }
-      if (this.p && !this.k[0]) {
-        this.k[0] = compute(this.f[0] = new Owner(), this.p, null);
+      if (this.q && !this.k[0]) {
+        this.k[0] = compute(
+          this.f[0] = new Owner(),
+          this.q,
+          null
+        );
       }
     } else if (this.w === 0) {
       if (this.f[0])
         this.f[0].dispose();
       this.k = new Array(newLen);
       for (j = 0; j < newLen; j++) {
-        this.q[j] = newItems[j];
+        this.r[j] = newItems[j];
         this.k[j] = compute(this.f[j] = new Owner(), mapper, null);
       }
       this.w = newLen;
     } else {
       let start, end, newEnd, item, key, newIndices, newIndicesNext, temp = new Array(newLen), tempNodes = new Array(newLen), tempRows = this.g ? new Array(newLen) : void 0, tempIndexes = this.l ? new Array(newLen) : void 0;
-      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.q[start] === newItems[start] || this.g && compare(this.y, this.q[start], newItems[start])); start++) {
+      for (start = 0, end = Math.min(this.w, newLen); start < end && (this.r[start] === newItems[start] || this.g && compare(this.y, this.r[start], newItems[start])); start++) {
         if (this.g)
           this.g[start].write(newItems[start]);
       }
-      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.q[end] === newItems[newEnd] || this.g && compare(this.y, this.q[end], newItems[newEnd])); end--, newEnd--) {
+      for (end = this.w - 1, newEnd = newLen - 1; end >= start && newEnd >= start && (this.r[end] === newItems[newEnd] || this.g && compare(this.y, this.r[end], newItems[newEnd])); end--, newEnd--) {
         temp[newEnd] = this.k[end];
         tempNodes[newEnd] = this.f[end];
         tempRows && (tempRows[newEnd] = this.g[end]);
@@ -1376,7 +1394,7 @@ function updateKeyedMap() {
         newIndices.set(key, j);
       }
       for (i = start; i <= end; i++) {
-        item = this.q[i];
+        item = this.r[i];
         key = this.y ? this.y(item) : item;
         j = newIndices.get(key);
         if (j !== void 0 && j !== -1) {
@@ -1406,7 +1424,7 @@ function updateKeyedMap() {
         }
       }
       this.k = this.k.slice(0, this.w = newLen);
-      this.q = newItems.slice(0);
+      this.r = newItems.slice(0);
     }
   });
   return this.k;

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

@@ -7,7 +7,8 @@
 export declare const STATE_CLEAN = 0;
 export declare const STATE_CHECK = 1;
 export declare const STATE_DIRTY = 2;
-export declare const STATE_DISPOSED = 3;
+export declare const STATE_UNINITIALIZED = 3;
+export declare const STATE_DISPOSED = 4;
 export declare const EFFECT_PURE = 0;
 export declare const EFFECT_RENDER = 1;
 export declare const EFFECT_USER = 2;

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

@@ -85,6 +85,11 @@ export declare function setContext<T>(context: Context<T>, value?: T, owner?: Ow
  */
 export declare function hasContext(context: Context<any>, owner?: Owner | null): boolean;
 /**
- * Runs the given function when the parent owner computation is being disposed.
+ * Runs an effect once before the reactive scope is disposed
+ * @param fn an effect that should run only once on cleanup
+ *
+ * @returns the same {@link fn} function that was passed in
+ *
+ * @description https://docs.solidjs.com/reference/lifecycle/on-cleanup
  */
-export declare function onCleanup(disposable: Disposable): void;
+export declare function onCleanup(fn: Disposable): Disposable;

package/dist/types/map.d.ts

@@ -9,5 +9,5 @@ export type Maybe<T> = T | void | null | undefined | false;
  */
 export declare function mapArray<Item, MappedItem>(list: Accessor<Maybe<readonly Item[]>>, map: (value: Accessor<Item>, index: Accessor<number>) => MappedItem, options?: {
     keyed?: boolean | ((item: Item) => any);
-    fallback: Accessor<any>;
+    fallback?: Accessor<any>;
 }): Accessor<MappedItem[]>;

package/dist/types/signals.d.ts

@@ -8,6 +8,15 @@ 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 EffectFunction<Prev, Next extends Prev = Prev> = (v: Next, p?: Prev) => (() => void) | void;
+export interface EffectOptions {
+    name?: string;
+}
+export interface MemoOptions<T> extends EffectOptions {
+    equals?: false | ((prev: T, next: T) => boolean);
+}
+export type NoInfer<T extends any> = [T][T extends any ? 0 : never];
 /**
  * Creates a simple reactive state with a getter and setter
  * ```typescript
@@ -33,31 +42,85 @@ export type Signal<T> = [get: Accessor<T>, set: Setter<T>];
  */
 export declare function createSignal<T>(): Signal<T | undefined>;
 export declare function createSignal<T>(value: Exclude<T, Function>, options?: SignalOptions<T>): Signal<T>;
-export declare function createSignal<T>(fn: (prev?: T) => T, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
-export declare function createAsync<T>(fn: (prev?: T) => Promise<T> | AsyncIterable<T> | T, initial?: T, options?: SignalOptions<T>): Accessor<T>;
+export declare function createSignal<T>(fn: ComputeFunction<T>, initialValue?: T, options?: SignalOptions<T>): Signal<T>;
 /**
- * Creates a new computation whose value is computed and returned by the given function. The given
- * compute function is _only_ re-run when one of it's dependencies are updated. Dependencies are
- * are all signals that are read during execution.
+ * Creates a readonly derived reactive memoized signal
+ * ```typescript
+ * export function createMemo<T>(
+ *   compute: (v: 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-memo
  */
-export declare function createMemo<T>(compute: (prev?: T) => T, initialValue?: T, options?: SignalOptions<T>): Accessor<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>;
 /**
- * Invokes the given function each time any of the signals that are read inside are updated
- * (i.e., their value changes). The effect is immediately invoked on initialization.
+ * 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 createEffect<T>(compute: () => T, effect: (v: T) => (() => void) | void, initialValue?: T, options?: {
-    name?: string;
-}): void;
+export declare function createAsync<T>(compute: (prev?: T) => Promise<T> | AsyncIterable<T> | T, value?: T, options?: MemoOptions<T>): Accessor<T>;
 /**
- * Invokes the given function each time any of the signals that are read inside are updated
- * (i.e., their value changes). The effect is immediately invoked on initialization.
+ * Creates a reactive effect that runs after the render phase
+ * ```typescript
+ * export function createEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @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 effect a function that receives the new value and is used to perform side effects
+ * @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
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
  */
-export declare function createRenderEffect<T>(compute: () => T, effect: (v: T) => (() => void) | void, initialValue?: T, options?: {
-    name?: string;
-}): void;
+export declare function createEffect<Next>(compute: ComputeFunction<undefined | NoInfer<Next>, Next>, effect: EffectFunction<NoInfer<Next>, Next>): void;
+export declare function createEffect<Next, Init = Next>(compute: ComputeFunction<Init | Next, Next>, effect: EffectFunction<Next, Next>, value: Init, options?: EffectOptions): void;
 /**
- * Creates a computation root which is given a `dispose()` function to dispose of all inner
- * computations.
+ * Creates a reactive computation that runs during the render phase as DOM elements are created and updated but not necessarily connected
+ * ```typescript
+ * export function createRenderEffect<T>(
+ *   compute: (prev: T) => T,
+ *   effect: (v: T, prev: T) => (() => void) | void,
+ *   value?: T,
+ *   options?: { name?: string }
+ * ): void;
+ * ```
+ * @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 effect a function that receives the new value and is used to perform side effects
+ * @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
+ *
+ * @description https://docs.solidjs.com/reference/secondary-primitives/create-render-effect
+ */
+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 new non-tracked reactive context with manual disposal
+ *
+ * @param fn a function in which the reactive state is scoped
+ * @returns the output of `fn`.
+ *
+ * @description https://docs.solidjs.com/reference/reactive-utilities/create-root
  */
 export declare function createRoot<T>(init: ((dispose: () => void) => T) | (() => T)): T;
 /**