solid-ctrl-flow 1.0.32 → 1.0.33

package/dist/index.d.ts

@@ -64,10 +64,10 @@ export declare function bindTwoWay<S, D>(source: Signal<S>, dest: Signal<D>, to:
  * <>
  * ```
  */
-export declare function Case(props: {
+export declare const Case: (props: {
     value: any;
     children: JSX.Element;
-}): JSX.Element;
+}) => JSX.Element;
 
 /**
  * Returns a {@link Signal} that applies the `??=` operator to the input one.
@@ -118,44 +118,25 @@ export declare function createExtractor(name?: string): {
     readonly extracting: () => number | null;
 };
 
-/**
- * Creates a context with a reactive value.
- * Returns a provider with additional fields:
- * - The `read` getter, which returns an {@link Accessor} to the value
- * - The `runWith()` method, which executes {@link runWithContext} on the option
- * @param init Initial value for the context
- * @param def Default value to set when calling the provider without one
- * @param name Name to give to the context
- */
-export declare function createOption<T>(init: T, def?: T, name?: string): {
-    (props: {
-        value?: T;
-        children: JSX.Element;
-    }): JSX.Element;
-    /** Executes {@link runWithContext} on the provided option */
-    runWith<V extends T, R>(x: V, f: (x: V) => R): R;
-} & {
-    /** Returns the {@link Accessor} for the value in the current context */
-    read: Accessor<T>;
-};
-
 /**
  * Creates a {@link Resource} from the function {@link f}.
- * The resource will be refetched each time one of the dependencies of {@link f} changes
+ * The resource will be refetched each time one of the dependencies of {@link f} changes.
+ * The only dependant signals that will be tracked are the ones before the first `await`
  * @param f A reactive resource fetcher
  */
 export declare function createReactiveResource<R>(f: EffectFunction<R | undefined, R>): Resource<Awaited<R>>;
 
-/** Creates a scope for the value of {@link Debug.read}, which allows you to display different things in debug mode */
-export declare const Debug: {
-    (props: {
-        value?: boolean | undefined;
-        children: JSX.Element;
-    }): JSX.Element;
-    runWith<V extends boolean, R>(x: V, f: (x: V) => R): R;
-} & {
-    read: Accessor<boolean>;
-};
+/** Creates a scope for the value of {@link Debug.isDebug}, which allows you to display different things in debug mode */
+export declare function Debug(props: {
+    value?: boolean;
+    children?: JSX.Element;
+}): JSX.Element;
+
+/** Internals of {@link Debug} */
+export declare namespace Debug {
+    /** Returns an {@link Accessor} that tells whether the current {@link Owner} is in debug mode */
+    const isDebug: Accessor<boolean>;
+}
 
 /** Informations about a {@link Source} component */
 declare type Info = {
@@ -172,12 +153,46 @@ declare type Info = {
  */
 export declare function memoProps<T, K extends readonly (keyof T)[] = (keyof T)[]>(obj: T, keys?: K): Pick<T, K[number]>;
 
-/** Like a {@link Suspence}, but enables you to turn it off and show the loading state */
-export declare function OptionalSuspense(props: {
-    active: boolean;
-    children: JSX.Element;
-    fallback?: JSX.Element;
-}): JSX.Element;
+/**
+ * Reactive {@link Context} with some additional built-in functionalities.
+ * The call signature returns the value in the current {@link Owner} (It's like calling {@link read})
+ */
+export declare abstract class ReactiveContext<T> extends ReactiveContext_base<T> {
+    /** The actual {@link Context} that contains the reactive {@link Accessor} to the value */
+    abstract ctx: Context<Accessor<T>>;
+    /**
+     * Returns the {@link Accessor} for the value in the current {@link Owner}.
+     * It's like calling {@link useContext}
+     */
+    get read(): Accessor<T>;
+    /**
+     * Component that sets the value of the current {@link Context} for its children.
+     * If no value is provided then it will use the default value for {@link ctx}.
+     * The function is binded for the way solid compiles components inside other objects.
+     * (The value is memoized)
+     */
+    get Provider(): (props: {
+        value?: T;
+        children: JSX.Element;
+    }) => JSX.Element;
+    /**
+     * Executes {@link runWithContext} on the current context
+     * @param value The value for the context
+     * @param f The function to run
+     * @returns The same thing {@link f} returned
+     */
+    runWith<V extends T, R>(value: V, f: (x: V) => R): R;
+    runWith<R>(value: T | undefined, f: (x: T) => R): R;
+    /**
+     * Creates a {@link ReactiveContext}
+     * @param defaultValue Initial value for the context
+     * @param name Name to give to the context
+     */
+    static create<T>(defaultValue?: undefined, name?: string): ReactiveContext<T | undefined>;
+    static create<T>(defaultValue: T, name?: string): ReactiveContext<T>;
+}
+
+declare const ReactiveContext_base: new <T_1>() => Accessor<T_1>;
 
 /**
  * Executes a {@link Ref}.
@@ -188,13 +203,6 @@ export declare function OptionalSuspense(props: {
  */
 export declare function refCall<T, U extends T = T>(ref: Ref<T> | undefined, value: U): U;
 
-/**
- * Executes {@link f} and then calls {@link d} regardless of errors.
- * If {@link f} returns a {@link Promise}, {@link d} will be called asynchronously
- * @returns The same thing {@link f} returned
- */
-export declare function runAndDispose<R>(d: () => void, f: () => R): R;
-
 /**
  * Executes {@link f} with the provided value for the specified {@link Context}.
  * You can pass `undefined` to {@link value} in order to get back the default value for {@link ctx}.
@@ -204,7 +212,9 @@ export declare function runAndDispose<R>(d: () => void, f: () => R): R;
  * @param f The function to run
  * @returns The same thing {@link f} returned
  */
-export declare function runWithContext<T, R>(ctx: Context<T>, value: T | undefined, f: (x: T | undefined) => R): R;
+export declare function runWithContext<T, V extends T, R>(ctx: Context<T>, value: V, f: (x: V) => R): R;
+
+export declare function runWithContext<T, R>(ctx: Context<T>, value: T | undefined, f: (x: T) => R): R;
 
 /**
  * Executes {@link splitProps} and memoizes the first of the two returned objects
@@ -235,7 +245,7 @@ export declare function toSignal<T, K extends keyof T>(obj: Accessor<T>, k: Acce
  * @param args Arguments for calling {@link f}
  * @returns The same thing {@link f} returned
  */
-export declare function untrackCall<F extends (...args: any[]) => any>(this: ThisParameterType<F>, f: F, ...args: Parameters<F>): ReturnType<F>;
+export declare function untrackCall<F extends (...args: any[]) => unknown>(this: ThisParameterType<F>, f: F, ...args: Parameters<F>): ReturnType<F>;
 
 /**
  * Calls {@link f} maintaining its reactivity

package/dist/index.mjs

@@ -1,120 +1,88 @@
-import { untrack, createMemo, splitProps, createContext, createRoot, createEffect, on, createResource, createComponent, useContext, getOwner, createRenderEffect, onCleanup, Match, mergeProps, For, Show, Suspense } from "solid-js";
+import { useContext, createMemo, createComponent, createContext, Match, mergeProps, onCleanup, For, Show, createRoot, createRenderEffect, on, untrack, splitProps, getOwner, createEffect, createResource } from "solid-js";
 import { createMutable } from "solid-js/store";
-function untrackCall(f, ...args) {
-  return untrack(() => f.apply(this, args));
-}
-function refCall(ref, value) {
-  if (!ref)
-    return value;
-  if (typeof ref !== "function")
-    throw new ReferenceError('Il parametro "ref" deve essere stato compilato in una funzione a runtime');
-  ref(value);
-  return value;
-}
-function memoProps(obj, keys = Object.keys(obj)) {
-  const out = {};
-  for (const elm of keys)
-    Object.defineProperty(out, elm, {
-      enumerable: true,
-      get: createMemo(() => obj[elm])
-    });
-  return out;
-}
-function splitAndMemoProps(obj, keys) {
-  const out = splitProps(obj, keys);
-  out[0] = memoProps(out[0], keys);
-  return out;
-}
-function createOption(init, def = init, name) {
-  const prop = "read";
-  const ctx2 = createContext(() => init, {
-    name
-  });
-  const provider = (props) => createComponent(ctx2.Provider, {
-    value: () => props.value ?? def,
-    get children() {
-      return props.children;
-    }
-  });
-  Object.defineProperty(provider, prop, {
-    get: () => useContext(ctx2)
-  });
-  provider.runWith = (x, f) => runWithContext(ctx2, () => x, () => f(x));
-  return provider;
-}
-function runWithContext(ctx2, value, f) {
-  return createRoot((d) => {
-    return runAndDispose(d, () => {
-      (getOwner().context ??= {})[ctx2.id] = value;
-      return f(value);
+class ReactiveContext extends Function {
+  /** The actual {@link Context} that contains the reactive {@link Accessor} to the value */
+  /**
+   * Returns the {@link Accessor} for the value in the current {@link Owner}.
+   * It's like calling {@link useContext}
+   */
+  get read() {
+    return useContext(this.ctx);
+  }
+  /**
+   * Component that sets the value of the current {@link Context} for its children.
+   * If no value is provided then it will use the default value for {@link ctx}.
+   * The function is binded for the way solid compiles components inside other objects.
+   * (The value is memoized)
+   */
+  get Provider() {
+    const {
+      ctx: ctx2
+    } = this;
+    return function(props) {
+      const memo = createMemo(() => props.value);
+      return createComponent(ctx2.Provider, {
+        value: memo,
+        get children() {
+          return props.children;
+        }
+      });
+    };
+  }
+  /**
+   * Executes {@link runWithContext} on the current context
+   * @param value The value for the context
+   * @param f The function to run
+   * @returns The same thing {@link f} returned
+   */
+  runWith(value, f) {
+    return runWithContext(this.ctx, value === void 0 ? void 0 : () => value, (x) => f(x()));
+  }
+  /**
+   * Creates a {@link ReactiveContext}
+   * @param defaultValue Initial value for the context
+   * @param name Name to give to the context
+   */
+  static create(defaultValue, name) {
+    const ctx2 = createContext(() => defaultValue, {
+      name
     });
-  });
-}
-function createReactiveResource(f) {
-  var refetch;
-  const memo = createMemo(f);
-  createEffect(on(memo, () => refetch?.()));
-  const [get] = [, {
-    refetch
-  }] = createResource(memo);
-  return get;
-}
-function runAndDispose(d, f) {
-  try {
-    const out = f();
-    return out instanceof Promise ? out.finally(d) : (d(), out);
-  } catch (ex) {
-    throw d(), ex;
+    const f = () => out.read();
+    f.ctx = ctx2;
+    const out = Object.setPrototypeOf(f, ReactiveContext.prototype);
+    return out;
   }
 }
-const IDENTITY = (x) => x;
-function bind([get], [, set], to = IDENTITY) {
-  const d = createRoot((d2) => (createRenderEffect(on(get, (x) => set((prev) => to(x, prev)))), d2));
-  return onCleanup(d), d;
-}
-function bindTwoWay(source, dest, to = IDENTITY, from = IDENTITY) {
-  const a = bind(source, dest, to);
-  const b = bind(dest, source, from);
-  return () => (a(), b());
-}
-function toSetter(get, set) {
-  return (x) => {
-    const out = typeof x === "function" ? x(untrack(get)) : x;
-    return set(out), out;
-  };
-}
-function toSignal(obj, k) {
-  const get = () => obj()[k()];
-  return [get, toSetter(get, (v) => obj()[k()] = v)];
-}
-function coalesceSignal([get, set], f) {
-  return [() => get() ?? set(f), set];
-}
-function unwrapSignal(f) {
-  return [() => f()[0](), (x) => f()[1](x)];
-}
-const ctx = createContext(() => void 0, {
-  name: "case-when"
-});
-function Case(props) {
-  const memo = createMemo(() => props.value);
-  return createComponent(ctx.Provider, {
-    value: memo,
-    get children() {
-      return props.children;
-    }
-  });
-}
+const ctx$1 = ReactiveContext.create(void 0, "case-when");
+const Case = ctx$1.Provider;
 function When(props) {
   const [mine, other] = splitAndMemoProps(props, ["value", "pred"]);
-  const value = useContext(ctx);
+  const {
+    read
+  } = ctx$1;
   const pred = (x) => mine.pred ? mine.pred(x) : x === mine.value;
   return createComponent(Match, mergeProps({
     get when() {
-      return pred(value());
+      return pred(read());
     }
   }, other));
 }
+const ctx = ReactiveContext.create(false, "debug-scope");
+function Debug(props) {
+  return createComponent(ctx.Provider, {
+    get value() {
+      return props.value ?? true;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+}
+(function(_Debug) {
+  Object.defineProperty(Debug, "isDebug", {
+    get: () => ctx.read
+  });
+})(Debug || (Debug = {}));
 function createExtractor(name = "extractor") {
   const ctx2 = createContext(void 0, {
     name
@@ -188,41 +156,88 @@ function Joint(props) {
     }
   });
 }
-const Debug = createOption(false, true, "debug-scope");
-function OptionalSuspense(props) {
-  return createComponent(Show, {
-    get when() {
-      return props.active;
-    },
-    get fallback() {
-      return props.children;
-    },
-    get children() {
-      return createComponent(Suspense, {
-        get fallback() {
-          return props.fallback;
-        },
-        get children() {
-          return props.children;
-        }
-      });
+const IDENTITY = (x) => x;
+function bind([get], [, set], to = IDENTITY) {
+  const d = createRoot((d2) => (createRenderEffect(on(get, (x) => set((prev) => to(x, prev)))), d2));
+  return onCleanup(d), d;
+}
+function bindTwoWay(source, dest, to = IDENTITY, from = IDENTITY) {
+  const a = bind(source, dest, to);
+  const b = bind(dest, source, from);
+  return () => (a(), b());
+}
+function toSetter(get, set) {
+  return (x) => {
+    const out = typeof x === "function" ? x(untrack(get)) : x;
+    return set(out), out;
+  };
+}
+function toSignal(obj, k) {
+  const get = () => obj()[k()];
+  return [get, toSetter(get, (v) => obj()[k()] = v)];
+}
+function coalesceSignal([get, set], f) {
+  return [() => get() ?? set(f), set];
+}
+function unwrapSignal(f) {
+  return [() => f()[0](), (x) => f()[1](x)];
+}
+function untrackCall(f, ...args) {
+  return untrack(() => f.apply(this, args));
+}
+function refCall(ref, value) {
+  if (!ref)
+    return value;
+  if (typeof ref !== "function")
+    throw new ReferenceError('Il parametro "ref" deve essere stato compilato in una funzione a runtime');
+  ref(value);
+  return value;
+}
+function memoProps(obj, keys = Object.keys(obj)) {
+  const out = {};
+  for (const elm of keys)
+    Object.defineProperty(out, elm, {
+      enumerable: true,
+      get: createMemo(() => obj[elm])
+    });
+  return out;
+}
+function splitAndMemoProps(obj, keys) {
+  const out = splitProps(obj, keys);
+  out[0] = memoProps(out[0], keys);
+  return out;
+}
+function runWithContext(ctx2, value, f) {
+  return createRoot((d) => {
+    try {
+      (getOwner().context ??= {})[ctx2.id] = value;
+      return f(value === void 0 ? ctx2.defaultValue : value);
+    } finally {
+      d();
     }
   });
 }
+function createReactiveResource(f) {
+  var refetch;
+  const memo = createMemo(f);
+  createEffect(on(memo, () => refetch?.()));
+  const [get] = [, {
+    refetch
+  }] = createResource(memo);
+  return get;
+}
 export {
   Case,
   Debug,
-  OptionalSuspense,
+  ReactiveContext,
   When,
   bind,
   bindTwoWay,
   coalesceSignal,
   createExtractor,
-  createOption,
   createReactiveResource,
   memoProps,
   refCall,
-  runAndDispose,
   runWithContext,
   splitAndMemoProps,
   toSetter,

package/dist/index.umd.js

@@ -2,121 +2,89 @@
   typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("solid-js"), require("solid-js/store")) : typeof define === "function" && define.amd ? define(["exports", "solid-js", "solid-js/store"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.solidCtrlFlow = {}, global.solidJs, global.solidJsStore));
 })(this, function(exports2, solidJs, store) {
   "use strict";
-  function untrackCall(f, ...args) {
-    return solidJs.untrack(() => f.apply(this, args));
-  }
-  function refCall(ref, value) {
-    if (!ref)
-      return value;
-    if (typeof ref !== "function")
-      throw new ReferenceError('Il parametro "ref" deve essere stato compilato in una funzione a runtime');
-    ref(value);
-    return value;
-  }
-  function memoProps(obj, keys = Object.keys(obj)) {
-    const out = {};
-    for (const elm of keys)
-      Object.defineProperty(out, elm, {
-        enumerable: true,
-        get: solidJs.createMemo(() => obj[elm])
-      });
-    return out;
-  }
-  function splitAndMemoProps(obj, keys) {
-    const out = solidJs.splitProps(obj, keys);
-    out[0] = memoProps(out[0], keys);
-    return out;
-  }
-  function createOption(init, def = init, name) {
-    const prop = "read";
-    const ctx2 = solidJs.createContext(() => init, {
-      name
-    });
-    const provider = (props) => solidJs.createComponent(ctx2.Provider, {
-      value: () => props.value ?? def,
-      get children() {
-        return props.children;
-      }
-    });
-    Object.defineProperty(provider, prop, {
-      get: () => solidJs.useContext(ctx2)
-    });
-    provider.runWith = (x, f) => runWithContext(ctx2, () => x, () => f(x));
-    return provider;
-  }
-  function runWithContext(ctx2, value, f) {
-    return solidJs.createRoot((d) => {
-      return runAndDispose(d, () => {
-        (solidJs.getOwner().context ??= {})[ctx2.id] = value;
-        return f(value);
+  class ReactiveContext extends Function {
+    /** The actual {@link Context} that contains the reactive {@link Accessor} to the value */
+    /**
+     * Returns the {@link Accessor} for the value in the current {@link Owner}.
+     * It's like calling {@link useContext}
+     */
+    get read() {
+      return solidJs.useContext(this.ctx);
+    }
+    /**
+     * Component that sets the value of the current {@link Context} for its children.
+     * If no value is provided then it will use the default value for {@link ctx}.
+     * The function is binded for the way solid compiles components inside other objects.
+     * (The value is memoized)
+     */
+    get Provider() {
+      const {
+        ctx: ctx2
+      } = this;
+      return function(props) {
+        const memo = solidJs.createMemo(() => props.value);
+        return solidJs.createComponent(ctx2.Provider, {
+          value: memo,
+          get children() {
+            return props.children;
+          }
+        });
+      };
+    }
+    /**
+     * Executes {@link runWithContext} on the current context
+     * @param value The value for the context
+     * @param f The function to run
+     * @returns The same thing {@link f} returned
+     */
+    runWith(value, f) {
+      return runWithContext(this.ctx, value === void 0 ? void 0 : () => value, (x) => f(x()));
+    }
+    /**
+     * Creates a {@link ReactiveContext}
+     * @param defaultValue Initial value for the context
+     * @param name Name to give to the context
+     */
+    static create(defaultValue, name) {
+      const ctx2 = solidJs.createContext(() => defaultValue, {
+        name
       });
-    });
-  }
-  function createReactiveResource(f) {
-    var refetch;
-    const memo = solidJs.createMemo(f);
-    solidJs.createEffect(solidJs.on(memo, () => refetch?.()));
-    const [get] = [, {
-      refetch
-    }] = solidJs.createResource(memo);
-    return get;
-  }
-  function runAndDispose(d, f) {
-    try {
-      const out = f();
-      return out instanceof Promise ? out.finally(d) : (d(), out);
-    } catch (ex) {
-      throw d(), ex;
+      const f = () => out.read();
+      f.ctx = ctx2;
+      const out = Object.setPrototypeOf(f, ReactiveContext.prototype);
+      return out;
     }
   }
-  const IDENTITY = (x) => x;
-  function bind([get], [, set], to = IDENTITY) {
-    const d = solidJs.createRoot((d2) => (solidJs.createRenderEffect(solidJs.on(get, (x) => set((prev) => to(x, prev)))), d2));
-    return solidJs.onCleanup(d), d;
-  }
-  function bindTwoWay(source, dest, to = IDENTITY, from = IDENTITY) {
-    const a = bind(source, dest, to);
-    const b = bind(dest, source, from);
-    return () => (a(), b());
-  }
-  function toSetter(get, set) {
-    return (x) => {
-      const out = typeof x === "function" ? x(solidJs.untrack(get)) : x;
-      return set(out), out;
-    };
-  }
-  function toSignal(obj, k) {
-    const get = () => obj()[k()];
-    return [get, toSetter(get, (v) => obj()[k()] = v)];
-  }
-  function coalesceSignal([get, set], f) {
-    return [() => get() ?? set(f), set];
-  }
-  function unwrapSignal(f) {
-    return [() => f()[0](), (x) => f()[1](x)];
-  }
-  const ctx = solidJs.createContext(() => void 0, {
-    name: "case-when"
-  });
-  function Case(props) {
-    const memo = solidJs.createMemo(() => props.value);
-    return solidJs.createComponent(ctx.Provider, {
-      value: memo,
-      get children() {
-        return props.children;
-      }
-    });
-  }
+  const ctx$1 = ReactiveContext.create(void 0, "case-when");
+  const Case = ctx$1.Provider;
   function When(props) {
     const [mine, other] = splitAndMemoProps(props, ["value", "pred"]);
-    const value = solidJs.useContext(ctx);
+    const {
+      read
+    } = ctx$1;
     const pred = (x) => mine.pred ? mine.pred(x) : x === mine.value;
     return solidJs.createComponent(solidJs.Match, solidJs.mergeProps({
       get when() {
-        return pred(value());
+        return pred(read());
       }
     }, other));
   }
+  const ctx = ReactiveContext.create(false, "debug-scope");
+  function Debug(props) {
+    return solidJs.createComponent(ctx.Provider, {
+      get value() {
+        return props.value ?? true;
+      },
+      get children() {
+        return props.children;
+      }
+    });
+  }
+  (function(_Debug) {
+    Object.defineProperty(Debug, "isDebug", {
+      get: () => ctx.read
+    });
+  })(Debug || (Debug = {}));
   function createExtractor(name = "extractor") {
     const ctx2 = solidJs.createContext(void 0, {
       name
@@ -190,40 +158,87 @@
       }
     });
   }
-  const Debug = createOption(false, true, "debug-scope");
-  function OptionalSuspense(props) {
-    return solidJs.createComponent(solidJs.Show, {
-      get when() {
-        return props.active;
-      },
-      get fallback() {
-        return props.children;
-      },
-      get children() {
-        return solidJs.createComponent(solidJs.Suspense, {
-          get fallback() {
-            return props.fallback;
-          },
-          get children() {
-            return props.children;
-          }
-        });
+  const IDENTITY = (x) => x;
+  function bind([get], [, set], to = IDENTITY) {
+    const d = solidJs.createRoot((d2) => (solidJs.createRenderEffect(solidJs.on(get, (x) => set((prev) => to(x, prev)))), d2));
+    return solidJs.onCleanup(d), d;
+  }
+  function bindTwoWay(source, dest, to = IDENTITY, from = IDENTITY) {
+    const a = bind(source, dest, to);
+    const b = bind(dest, source, from);
+    return () => (a(), b());
+  }
+  function toSetter(get, set) {
+    return (x) => {
+      const out = typeof x === "function" ? x(solidJs.untrack(get)) : x;
+      return set(out), out;
+    };
+  }
+  function toSignal(obj, k) {
+    const get = () => obj()[k()];
+    return [get, toSetter(get, (v) => obj()[k()] = v)];
+  }
+  function coalesceSignal([get, set], f) {
+    return [() => get() ?? set(f), set];
+  }
+  function unwrapSignal(f) {
+    return [() => f()[0](), (x) => f()[1](x)];
+  }
+  function untrackCall(f, ...args) {
+    return solidJs.untrack(() => f.apply(this, args));
+  }
+  function refCall(ref, value) {
+    if (!ref)
+      return value;
+    if (typeof ref !== "function")
+      throw new ReferenceError('Il parametro "ref" deve essere stato compilato in una funzione a runtime');
+    ref(value);
+    return value;
+  }
+  function memoProps(obj, keys = Object.keys(obj)) {
+    const out = {};
+    for (const elm of keys)
+      Object.defineProperty(out, elm, {
+        enumerable: true,
+        get: solidJs.createMemo(() => obj[elm])
+      });
+    return out;
+  }
+  function splitAndMemoProps(obj, keys) {
+    const out = solidJs.splitProps(obj, keys);
+    out[0] = memoProps(out[0], keys);
+    return out;
+  }
+  function runWithContext(ctx2, value, f) {
+    return solidJs.createRoot((d) => {
+      try {
+        (solidJs.getOwner().context ??= {})[ctx2.id] = value;
+        return f(value === void 0 ? ctx2.defaultValue : value);
+      } finally {
+        d();
       }
     });
   }
+  function createReactiveResource(f) {
+    var refetch;
+    const memo = solidJs.createMemo(f);
+    solidJs.createEffect(solidJs.on(memo, () => refetch?.()));
+    const [get] = [, {
+      refetch
+    }] = solidJs.createResource(memo);
+    return get;
+  }
   exports2.Case = Case;
   exports2.Debug = Debug;
-  exports2.OptionalSuspense = OptionalSuspense;
+  exports2.ReactiveContext = ReactiveContext;
   exports2.When = When;
   exports2.bind = bind;
   exports2.bindTwoWay = bindTwoWay;
   exports2.coalesceSignal = coalesceSignal;
   exports2.createExtractor = createExtractor;
-  exports2.createOption = createOption;
   exports2.createReactiveResource = createReactiveResource;
   exports2.memoProps = memoProps;
   exports2.refCall = refCall;
-  exports2.runAndDispose = runAndDispose;
   exports2.runWithContext = runWithContext;
   exports2.splitAndMemoProps = splitAndMemoProps;
   exports2.toSetter = toSetter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-ctrl-flow",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "description": "Control flow components for solid-js",
   "author": "AFatNiBBa",
   "license": "ISC",

package/readMe.md

@@ -1,6 +1,7 @@
 
 # solid-ctrl-flow
-Control flow components for "solid-js"
+Control flow components for "solid-js".
+It's always under hard development
 
 ## Components
 
@@ -40,16 +41,13 @@ const value = false;
 return <>
   <Debug value={value}>
     {/* (A LOT OF NESTING...) */}
-    <Show when={Debug.read()}>
+    <Show when={Debug.isDebug()}>
       THIS WOULD BE VISIBLE IF "value" HAD BEEN {true}
     </Show>
   </Debug>
 </>
 ```
 
-### `OptionalSuspense`
-Like a `Suspence`, but enables you to turn it off and show the loading state
-
 ### `createExtractor()`
 Creates a context for components that may need to be out of their parent in certain conditions.
 If you have this component
@@ -124,6 +122,15 @@ Notice that you can use a `Source` component without adding it to the DOM:
 return <>Something else</>
 ```
 
+### `ReactiveContext.create()`
+Method that creates a reactive version of a solid `Context` with some additional built-in functionalities
+```ts
+const ctx = ReactiveContext.create("SOMETHING");
+const underlyingNormalContext = ctx.ctx;
+const valueAccessorForTheCurrentOwner = ctx.read;
+const value = ctx();
+```
+
 ## Bindings
 Functions that create bindings between `Signal`s
 
@@ -160,14 +167,8 @@ Creates a partial version of an object with memoized remaining properties
 ### `splitAndMemoProps()`
 Like `splitProps()` but memoizes the whole local part
 
-### `createOption()`
-Allows you to create simple reactive contexts; For example `Debug` is made with it
-
 ### `runWithContext()`
 Creates a context scope that persists for the duration of a function
 
 ### `createReactiveResource()`
-Like `createResource()` but the provided function will be reactive
-
-### `runAndDispose()`
-Executes a function THEN calls a dispose callback; It works with async functions too
+Like `createResource()` but the provided function will be reactive