solid-ctrl-flow 1.0.59 → 1.0.61

package/dist/index.d.ts

@@ -4,46 +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 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>;

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 {
@@ -224,51 +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), (x) => this.value = from(x));
-  }
-  /**
-   * 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);
-  }
-  /**
-   * 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));
-  }
-  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(() => {
@@ -277,7 +232,6 @@ function SameContext(props) {
   });
 }
 export {
-  Atom,
   Case,
   Enfold,
   On,

package/dist/index.umd.js

@@ -226,51 +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), (x) => this.value = from(x));
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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));
-    }
-    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(() => {
@@ -278,7 +233,6 @@
       return props.children;
     });
   }
-  exports2.Atom = Atom;
   exports2.Case = Case;
   exports2.Enfold = Enfold;
   exports2.On = On;

package/package.json

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

package/readMe.md

@@ -162,27 +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` from a `Signal`
->
-> #### `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