solid-ctrl-flow 1.0.60 → 1.0.61

package/dist/index.d.ts

@@ -4,53 +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>;
@@ -156,19 +109,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:

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { useContext, createMemo, createComponent, createContext, createRoot, getOwner, untrack, splitProps, Show, onCleanup, For, Match, mergeProps, on, createSignal } from "solid-js";
+import { useContext, createMemo, createComponent, createContext, createRoot, getOwner, untrack, splitProps, Show, onCleanup, For, Match, mergeProps } from "solid-js";
 import { createMutable } from "solid-js/store";
 const BASE_CTOR = Function;
 class ReactiveContext extends BASE_CTOR {
@@ -67,8 +67,6 @@ 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)
@@ -226,61 +224,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(() => {
@@ -289,7 +232,6 @@ function SameContext(props) {
   });
 }
 export {
-  Atom,
   Case,
   Enfold,
   On,
@@ -299,7 +241,6 @@ export {
   createExtractor,
   debug,
   memoProps,
-  nameOf,
   runWithContext,
   splitAndMemoProps,
   untrackCall,

package/dist/index.umd.js

@@ -69,8 +69,6 @@
   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)
@@ -228,61 +226,6 @@
       }
     }, 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(() => {
@@ -290,7 +233,6 @@
       return props.children;
     });
   }
-  exports2.Atom = Atom;
   exports2.Case = Case;
   exports2.Enfold = Enfold;
   exports2.On = On;
@@ -299,7 +241,6 @@
   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.61",
   "description": "Control flow components for solid-js",
   "author": "AFatNiBBa",
   "license": "ISC",

package/readMe.md

@@ -162,30 +162,6 @@ 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
@@ -218,9 +194,6 @@ 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