solid-ctrl-flow 1.0.58 → 1.0.60

package/dist/index.d.ts

@@ -19,6 +19,12 @@ export declare class Atom<T> {
      * @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
@@ -30,12 +36,12 @@ export declare class Atom<T> {
      */
     static from<T>([get, set]: Signal<T>): Atom<T>;
     /**
-     * Creates a new {@link Atom} that applies a conversion to another {@link Atom}
-     * @param atom The {@link Atom} to which to apply the conversion
-     * @param to Conversion function from {@link S} to {@link D}
-     * @param from Conversion function from {@link D} to {@link S}
+     * 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 convert<S, D>(atom: Atom<S>, to: (x: S) => D, from: (x: D) => S): Atom<D>;
+    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
@@ -150,6 +156,19 @@ 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:

package/dist/index.mjs

@@ -67,6 +67,8 @@ function runWithContext(ctx2, value, f) {
 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)
@@ -243,12 +245,20 @@ class Atom {
   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, (x) => f().value = x);
+    return new this(() => f().value, (v) => f().value = v);
   }
   /**
    * Creates an {@link Atom} based on a {@link Signal}
@@ -258,13 +268,14 @@ class Atom {
     return new this(get, (v) => set(() => v));
   }
   /**
-      * Creates a new {@link Atom} that applies a conversion to another {@link Atom}
-      * @param atom The {@link Atom} to which to apply the conversion
-      * @param to Conversion function from {@link S} to {@link D}
-      * @param from Conversion function from {@link D} to {@link S}
-      */
-  static convert(atom, to, from) {
-    return new this(() => to(atom.value), (x) => atom.value = from(x));
+   * 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()))));
@@ -288,6 +299,7 @@ export {
   createExtractor,
   debug,
   memoProps,
+  nameOf,
   runWithContext,
   splitAndMemoProps,
   untrackCall,

package/dist/index.umd.js

@@ -69,6 +69,8 @@
   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)
@@ -245,12 +247,20 @@
     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, (x) => f().value = x);
+      return new this(() => f().value, (v) => f().value = v);
     }
     /**
      * Creates an {@link Atom} based on a {@link Signal}
@@ -260,13 +270,14 @@
       return new this(get, (v) => set(() => v));
     }
     /**
-        * Creates a new {@link Atom} that applies a conversion to another {@link Atom}
-        * @param atom The {@link Atom} to which to apply the conversion
-        * @param to Conversion function from {@link S} to {@link D}
-        * @param from Conversion function from {@link D} to {@link S}
-        */
-    static convert(atom, to, from) {
-      return new this(() => to(atom.value), (x) => atom.value = from(x));
+     * 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()))));
@@ -288,6 +299,7 @@
   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.58",
+  "version": "1.0.60",
   "description": "Control flow components for solid-js",
   "author": "AFatNiBBa",
   "license": "ISC",

package/readMe.md

@@ -171,14 +171,17 @@ Customizable and simplified wrappers for reactive states
 > #### `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` from a `Signal`
-> 
-> #### `Atom.convert()`
-> Creates a new `Atom` that applies a conversion to another `Atom`
+> 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
@@ -215,6 +218,9 @@ return <>
 ### `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