solid-ctrl-flow 1.0.60 → 1.0.62

package/dist/index.d.ts

@@ -4,56 +4,6 @@ import { JSX } from 'solid-js';
 import { MemoOptions } from 'solid-js';
 import { Owner } from 'solid-js';
 import { ParentProps } from 'solid-js';
-import { Signal } from 'solid-js';
-
-/** Reactive atomic value without the inconveniences of {@link Signal} */
-export declare class Atom<T> {
-    get: Accessor<T>;
-    set: (x: T) => void;
-    get value(): T;
-    set value(v: T);
-    constructor(get: Accessor<T>, set: (x: T) => void);
-    /**
-     * Allows you to set the current {@link Atom} based on its current value.
-     * The current value gets read through {@link untrack} to mimic the {@link Setter} behaviour
-     * @param f Function that creates a new value based on the current one
-     */
-    update<V extends T>(f: (prev: T) => V): V;
-    /**
-     * Creates a new {@link Atom} that applies a conversion to the current one
-     * @param to Conversion function from {@link S} to {@link D}
-     * @param from Conversion function from {@link D} to {@link S}
-     */
-    convert<R>(to: (x: T) => R, from: (x: R) => T): Atom<R>;
-    /**
-     * Creates an {@link Atom} that forwards an {@link Accessor} to another {@link Atom}
-     * @param f The reactive {@link Accessor} to the {@link Atom} to forward
-     */
-    static unwrap<T>(f: Accessor<Atom<T>>): Atom<T>;
-    /**
-     * Creates an {@link Atom} based on a {@link Signal}
-     * @param param0 The {@link Signal} to forward
-     */
-    static from<T>([get, set]: Signal<T>): Atom<T>;
-    /**
-     * Creates an {@link Atom} based on an object property.
-     * The result of {@link k} will be memoized, while {@link obj}'s one won't
-     * @param obj The object containing the property
-     * @param k A function that returns the key of the property and will be passed to {@link nameOf}
-     */
-    static prop<T, K extends keyof T>(obj: Accessor<T>, k: (x: NamesOf<T>) => K): Atom<T[K]>;
-    /**
-     * Creates a bindable data source.
-     * If {@link bind} returns an {@link Atom} it gets wrapped, otherwise it creates a {@link Signal} using {@link f} and uses it to store the value until {@link bind}'s value changes
-     * @param bind The bound {@link Atom}
-     * @param f The function that will create the actual {@link Signal} that will store the {@link Atom}'s data in case that {@link bind} doesn't return anything
-     */
-    static source<T>(bind: Accessor<Atom<T> | undefined>): Atom<T | undefined>;
-    static source<T>(bind: Accessor<Atom<T> | undefined>, f: Accessor<Signal<T>>): Atom<T>;
-}
-
-/** Type hack for making {@link ReactiveContext} implement {@link Accessor} */
-declare const BASE_CTOR: new <T>() => Accessor<T>;
 
 /** Like a {@link Match} but gets the value from the closest {@link On} ancestor */
 export declare function Case(props: ParentProps<{
@@ -120,9 +70,6 @@ export declare function createExtractor(name?: string): {
     readonly extracting: () => number | null;
 };
 
-/** Built-in {@link ReactiveContext} which allows you to display different things in debug mode */
-export declare const debug: ReactiveContext<boolean>;
-
 /**
  * Eventually wraps its content into a template if a certain condition is met.
  * If you set {@link Standard.recycled} to `true`, the content will be memoized in the beginning and will be recycled even if the wrapper changes.
@@ -156,19 +103,6 @@ export declare function memoProps<T>(obj: T, keys?: undefined, equals?: Equals):
 
 export declare function memoProps<T, K extends readonly (keyof T)[]>(obj: T, keys: K, equals?: Equals): Pick<T, K[number]>;
 
-/**
- * Function that returns the name of the field accessed inside of {@link f}.
- * This function is not meant to be used on its own because it has very poor type inference
- * @param f A function that returns a value based on {@link NamesOf}
- * @returns The same thing that {@link f} returned
- */
-export declare const nameOf: <T, const R>(f: (x: NamesOf<T>) => R) => R;
-
-/** Type that maps each key of {@link T} to itself */
-export declare type NamesOf<T> = {
-    [k in keyof T]: k;
-};
-
 /**
  * Allows the use of {@link Case}s inside of {@link Switch}es.
  * Example:
@@ -203,43 +137,6 @@ export declare const On: (props: ParentProps<{
     value: any;
 }>) => 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 get})
- */
-export declare abstract class ReactiveContext<T> extends BASE_CTOR<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 get(): 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 bound for the way solid compiles components inside other objects.
-     * (The value is memoized)
-     */
-    get Provider(): (props: ParentProps<{
-        value?: T;
-    }>) => 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 | undefined, f: (x: V) => 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>;
-}
-
 /**
  * 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}.

package/dist/index.mjs

@@ -1,74 +1,5 @@
-import { useContext, createMemo, createComponent, createContext, createRoot, getOwner, untrack, splitProps, Show, onCleanup, For, Match, mergeProps, on, createSignal } from "solid-js";
+import { createMemo, splitProps, untrack, createRoot, getOwner, createComponent, Show, createContext, useContext, onCleanup, For, Match, mergeProps } from "solid-js";
 import { createMutable } from "solid-js/store";
-const BASE_CTOR = Function;
-class ReactiveContext extends BASE_CTOR {
-  /** 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 get() {
-    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 bound 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
-    });
-    const f = () => out.get();
-    f.ctx = ctx2;
-    const out = Object.setPrototypeOf(f, ReactiveContext.prototype);
-    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 untrackCall(f, ...args) {
-  return untrack(() => f.apply(this, args));
-}
-const PROXY_KEYOF = new Proxy({}, { get: (_, k) => k });
-const nameOf = (f) => f(PROXY_KEYOF);
 function memoProps(obj, keys = Object.keys(obj), equals = false) {
   const out = {};
   for (const elm of keys)
@@ -80,6 +11,19 @@ function splitAndMemoProps(obj, keys, equals) {
   out[0] = memoProps(out[0], keys, equals);
   return out;
 }
+function untrackCall(f, ...args) {
+  return untrack(() => f.apply(this, args));
+}
+function runWithContext(ctx2, value, f) {
+  return createRoot((d) => {
+    try {
+      (getOwner().context ??= {})[ctx2.id] = value;
+      return f(value === void 0 ? ctx2.defaultValue : value);
+    } finally {
+      d();
+    }
+  });
+}
 const unwrap = (f) => new Proxy(f, HANDLER);
 const HANDLER = new Proxy({}, {
   get(cache, k) {
@@ -212,13 +156,18 @@ function createInfo(props) {
     }
   };
 }
-const ctx = ReactiveContext.create(void 0, "on-case");
-const On = ctx.Provider;
+const ctx = createContext(void 0, {
+  name: "on-case"
+});
+const On = (props) => createComponent(ctx.Provider, {
+  value: () => props.value,
+  get children() {
+    return props.children;
+  }
+});
 function Case(props) {
   const [mine, other] = splitAndMemoProps(props, ["value", "pred"]);
-  const {
-    get
-  } = ctx;
+  const get = useContext(ctx);
   const pred = (x) => mine.pred ? mine.pred(x) : x === mine.value;
   return createComponent(Match, mergeProps({
     get when() {
@@ -226,62 +175,6 @@ function Case(props) {
     }
   }, other));
 }
-class Atom {
-  constructor(get, set) {
-    this.get = get;
-    this.set = set;
-  }
-  get value() {
-    return this.get();
-  }
-  set value(v) {
-    this.set(v);
-  }
-  /**
-      * Allows you to set the current {@link Atom} based on its current value.
-      * The current value gets read through {@link untrack} to mimic the {@link Setter} behaviour
-      * @param f Function that creates a new value based on the current one
-      */
-  update(f) {
-    return this.value = f(untrack(this.get));
-  }
-  /**
-      * Creates a new {@link Atom} that applies a conversion to the current one
-      * @param to Conversion function from {@link S} to {@link D}
-      * @param from Conversion function from {@link D} to {@link S}
-      */
-  convert(to, from) {
-    return new Atom(() => to(this.value), (v) => this.value = from(v));
-  }
-  /**
-   * Creates an {@link Atom} that forwards an {@link Accessor} to another {@link Atom}
-   * @param f The reactive {@link Accessor} to the {@link Atom} to forward
-   */
-  static unwrap(f) {
-    return new this(() => f().value, (v) => f().value = v);
-  }
-  /**
-   * Creates an {@link Atom} based on a {@link Signal}
-   * @param param0 The {@link Signal} to forward
-   */
-  static from([get, set]) {
-    return new this(get, (v) => set(() => v));
-  }
-  /**
-   * Creates an {@link Atom} based on an object property.
-   * The result of {@link k} will be memoized, while {@link obj}'s one won't
-   * @param obj The object containing the property
-   * @param k A function that returns the key of the property and will be passed to {@link nameOf}
-   */
-  static prop(obj, k) {
-    const temp = createMemo(() => nameOf(k));
-    return new this(() => obj()[temp()], (v) => obj()[temp()] = v);
-  }
-  static source(bind, f = createSignal) {
-    return this.unwrap(createMemo(on(bind, (x) => x ?? Atom.from(f()))));
-  }
-}
-const debug = ReactiveContext.create(false, "debug-scope");
 function SameContext(props) {
   return createMemo(() => {
     getOwner().context = props.owner.context;
@@ -289,17 +182,13 @@ function SameContext(props) {
   });
 }
 export {
-  Atom,
   Case,
   Enfold,
   On,
-  ReactiveContext,
   SameContext,
   Slot,
   createExtractor,
-  debug,
   memoProps,
-  nameOf,
   runWithContext,
   splitAndMemoProps,
   untrackCall,

package/dist/index.umd.js

@@ -2,75 +2,6 @@
   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";
-  const BASE_CTOR = Function;
-  class ReactiveContext extends BASE_CTOR {
-    /** 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 get() {
-      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 bound 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
-      });
-      const f = () => out.get();
-      f.ctx = ctx2;
-      const out = Object.setPrototypeOf(f, ReactiveContext.prototype);
-      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 untrackCall(f, ...args) {
-    return solidJs.untrack(() => f.apply(this, args));
-  }
-  const PROXY_KEYOF = new Proxy({}, { get: (_, k) => k });
-  const nameOf = (f) => f(PROXY_KEYOF);
   function memoProps(obj, keys = Object.keys(obj), equals = false) {
     const out = {};
     for (const elm of keys)
@@ -82,6 +13,19 @@
     out[0] = memoProps(out[0], keys, equals);
     return out;
   }
+  function untrackCall(f, ...args) {
+    return solidJs.untrack(() => f.apply(this, args));
+  }
+  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();
+      }
+    });
+  }
   const unwrap = (f) => new Proxy(f, HANDLER);
   const HANDLER = new Proxy({}, {
     get(cache, k) {
@@ -214,13 +158,18 @@
       }
     };
   }
-  const ctx = ReactiveContext.create(void 0, "on-case");
-  const On = ctx.Provider;
+  const ctx = solidJs.createContext(void 0, {
+    name: "on-case"
+  });
+  const On = (props) => solidJs.createComponent(ctx.Provider, {
+    value: () => props.value,
+    get children() {
+      return props.children;
+    }
+  });
   function Case(props) {
     const [mine, other] = splitAndMemoProps(props, ["value", "pred"]);
-    const {
-      get
-    } = ctx;
+    const get = solidJs.useContext(ctx);
     const pred = (x) => mine.pred ? mine.pred(x) : x === mine.value;
     return solidJs.createComponent(solidJs.Match, solidJs.mergeProps({
       get when() {
@@ -228,78 +177,18 @@
       }
     }, other));
   }
-  class Atom {
-    constructor(get, set) {
-      this.get = get;
-      this.set = set;
-    }
-    get value() {
-      return this.get();
-    }
-    set value(v) {
-      this.set(v);
-    }
-    /**
-        * Allows you to set the current {@link Atom} based on its current value.
-        * The current value gets read through {@link untrack} to mimic the {@link Setter} behaviour
-        * @param f Function that creates a new value based on the current one
-        */
-    update(f) {
-      return this.value = f(solidJs.untrack(this.get));
-    }
-    /**
-        * Creates a new {@link Atom} that applies a conversion to the current one
-        * @param to Conversion function from {@link S} to {@link D}
-        * @param from Conversion function from {@link D} to {@link S}
-        */
-    convert(to, from) {
-      return new Atom(() => to(this.value), (v) => this.value = from(v));
-    }
-    /**
-     * Creates an {@link Atom} that forwards an {@link Accessor} to another {@link Atom}
-     * @param f The reactive {@link Accessor} to the {@link Atom} to forward
-     */
-    static unwrap(f) {
-      return new this(() => f().value, (v) => f().value = v);
-    }
-    /**
-     * Creates an {@link Atom} based on a {@link Signal}
-     * @param param0 The {@link Signal} to forward
-     */
-    static from([get, set]) {
-      return new this(get, (v) => set(() => v));
-    }
-    /**
-     * Creates an {@link Atom} based on an object property.
-     * The result of {@link k} will be memoized, while {@link obj}'s one won't
-     * @param obj The object containing the property
-     * @param k A function that returns the key of the property and will be passed to {@link nameOf}
-     */
-    static prop(obj, k) {
-      const temp = solidJs.createMemo(() => nameOf(k));
-      return new this(() => obj()[temp()], (v) => obj()[temp()] = v);
-    }
-    static source(bind, f = solidJs.createSignal) {
-      return this.unwrap(solidJs.createMemo(solidJs.on(bind, (x) => x ?? Atom.from(f()))));
-    }
-  }
-  const debug = ReactiveContext.create(false, "debug-scope");
   function SameContext(props) {
     return solidJs.createMemo(() => {
       solidJs.getOwner().context = props.owner.context;
       return props.children;
     });
   }
-  exports2.Atom = Atom;
   exports2.Case = Case;
   exports2.Enfold = Enfold;
   exports2.On = On;
-  exports2.ReactiveContext = ReactiveContext;
   exports2.SameContext = SameContext;
   exports2.createExtractor = createExtractor;
-  exports2.debug = debug;
   exports2.memoProps = memoProps;
-  exports2.nameOf = nameOf;
   exports2.runWithContext = runWithContext;
   exports2.splitAndMemoProps = splitAndMemoProps;
   exports2.untrackCall = untrackCall;

package/package.json

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

package/readMe.md

@@ -162,67 +162,17 @@ return <>
 
 ## Utility
 
-### `Atom`s
-Customizable and simplified wrappers for reactive states
-
-> #### `new Atom()`
-> Creates an `Atom` with custom getter and setter
-> 
-> #### `Atom.update()`
-> Like the `Setter` overload of a `Signal` that takes a function with the previous value
-> 
-> #### `Atom.convert()`
-> Creates a new `Atom` that applies a conversion to the current one
-> 
-> #### `Atom.unwrap()`
-> An `Atom`-specific (optimized) version of `unwrap()` that allows the destructuring of its result
-> 
-> #### `Atom.from()`
-> Creates an `Atom` based on a `Signal`
->
-> #### `Atom.prop()`
-> Creates an `Atom` based on an object property
->
-> #### `Atom.source()`
-> Similiar to `Atom.unwrap()`, but if the `Accessor` doesn't return anything it automatically creates an internal `Signal` in which to store the value
-
-### `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.get;
-const value = ctx();
-```
-
-### `runWithContext()`
-Creates a context scope that persists for the duration of a function
-
 ### `unwrap()`
 Calls an `Accessor` maintaining its reactivity at 1 level
 
-### `debug()`
-Allows you to define ui section that are only visible in debug or NOT in debug
-```tsx
-const value = false;
-return <>
-  <debug.Provider value={value}>
-    {/* (A LOT OF NESTING...) */}
-    <Show when={debug()}>
-      THIS WOULD BE VISIBLE IF "value" HAD BEEN {true}
-    </Show>
-  </debug.Provider>
-</>
-```
-
-### `untrackCall()`
-Calls a function untracking what happens inside of it but not what gets passed as its argument
-
-### `nameOf()`
-Utility function that powers `Atom.prop()`
-
 ### `memoProps()`
 Creates a partial version of an object with memoized remaining properties
 
 ### `splitAndMemoProps()`
-Like `splitProps()` but memoizes the whole local part
+Like `splitProps()` but memoizes the whole local part
+
+### `untrackCall()`
+Calls a function untracking what happens inside of it but not what gets passed as its argument
+
+### `runWithContext()`
+Creates a context scope that persists for the duration of a function