solid-ctrl-flow 1.0.59 → 1.0.60

package/dist/index.d.ts

@@ -35,6 +35,13 @@ export declare class Atom<T> {
      * @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
@@ -149,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)
@@ -249,14 +251,14 @@ class Atom {
       * @param from Conversion function from {@link D} to {@link S}
       */
   convert(to, from) {
-    return new Atom(() => to(this.value), (x) => this.value = from(x));
+    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}
@@ -265,6 +267,16 @@ class Atom {
   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()))));
   }
@@ -287,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)
@@ -251,14 +253,14 @@
         * @param from Conversion function from {@link D} to {@link S}
         */
     convert(to, from) {
-      return new Atom(() => to(this.value), (x) => this.value = from(x));
+      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}
@@ -267,6 +269,16 @@
     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()))));
     }
@@ -287,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.59",
+  "version": "1.0.60",
   "description": "Control flow components for solid-js",
   "author": "AFatNiBBa",
   "license": "ISC",

package/readMe.md

@@ -178,7 +178,10 @@ Customizable and simplified wrappers for reactive states
 > An `Atom`-specific (optimized) version of `unwrap()` that allows the destructuring of its result
 > 
 > #### `Atom.from()`
-> Creates an `Atom` from a `Signal`
+> 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