solid-state-tools 1.1.2 → 1.3.1

package/README.md

@@ -1,16 +1,33 @@
-# Solid JS State Tools
+# Solid State Tools
 
-This is a collection of simple utilities for managing [Solid JS](https://docs.solidjs.com/) state.
-It is intended to compliment Solid JS's existing state system, not replace it.
+Links: [GitHub Repository](https://github.com/ReedSyllas/solid-state-tools), [NPM Package](https://www.npmjs.com/package/solid-state-tools).
 
-This package is tiny and only has a peer dependency of Solid JS.
+Solid State Tools is a collection of simple utilities for managing [Solid JS](https://docs.solidjs.com/) state.
+
+All features are intended to compliment Solid JS's existing state system, building upon the existing foundation.
+
+The package is small and only has a peer dependency of Solid JS.
+
+# Usage
+
+This library introduces some new primitives:
+
+1. [atom](#atoms-atom)
+2. [createCouple](#couples-createcouple)
+
+And, a few shorthand functions that combine these primitives and those from Solid JS together.
+
+1. [asig](#atomic-signals-asig)
+2. [apair](#atomic-couples-apair)
+
+Read the sections below for a breakdown of each utility.
 
 ## Atoms (`atom`)
 
 Atoms combine the getter and setter of a [signal](https://docs.solidjs.com/concepts/signals) into one function.
 
 ```ts
-const count = atom(createSignal(0));
+const count: Atom<Signal<number>> = atom(createSignal(0));
 
 console.log(count()); // 0
 
@@ -24,29 +41,52 @@ count((c) => c + 1);
 console.log(count()); // 102
 ```
 
-When called with no arguments, the atom acts like the signal's getter. If an argument is passed, it is forwarded to the signal's setter. Note that `undefined` _is_ considered an argument and is forwarded to the setter, as desired.
+When called with no arguments, the atom acts like the signal's getter.
+If an argument is passed, it is forwarded to the signal's setter. Note that `undefined` _is_ considered an argument and is forwarded to the setter.
 
-Atoms simplify the boilerplate that comes with managing getters and setters separately. However, signals are still preferred for granular control of the getter and setter. Additionally, atoms incur a tiny performance cost. Thus, atoms do not replace signals. They coexist.
+Atoms simplify the boilerplate that comes with managing separate getters and setters.
+However, signals are still preferred when granular control of the getter and setter is needed.
+Additionally, atoms incur a tiny performance cost. Thus, atoms do not replace signals. They coexist.
 
 ## Atomic signals (`asig`)
 
-Because creating and wrapping a signal with `atom` is so common, a shorthand utility was created called `asig` (atomic signal).
+Creating a signal and immediately 'atomizing' it is a common pattern. The `asig` function was created for this, along with its related type `Asig`.
 
 ```ts
-const count = asig(0);
-// is a shorthand for
-const count = atom(createSignal(0));
+const count: Asig<number> = asig(0);
+// is short for
+const count: Atom<Signal<number>> = atom(createSignal(0));
 ```
 
-## Co-signals (`createCouple`)
-
-A signal can be summarized as a getter setter pair. However, Solid JS's setters are more complex than just a function that accepts the new value. They can also accept a function which acts like a map predicate from the old value to the new one.
+The second parameter (optional) is the config object, which is simply forwarded to the `createSignal` call.
 
 ```ts
-setCount(x => x + 1);
+const list = asig([], { equals: false });
+// is short for
+const list = atom(createSignal([], { equals: false }));
 ```
 
-All of this is to say that creating signal pairs can be tedious because the setter has to handle this edge case. Take a look at the below example.
+## Couples (`createCouple`)
+
+A signal can be summarized as a getter setter pair.
+However, the setter of a Solid JS signal is more complex than it appears at first glance.
+Why?
+
+1. It accepts a function which transforms the previous value into the new one.
+	```ts
+	setCount(x => x + 1);
+	```
+
+2. It also returns the value.
+	```ts
+	const [ _count, setCount ] = createSignal(0);
+
+	console.log(setCount(10));         // Prints: 10
+	console.log(setCount(x => x + 5)); // Prints: 15
+	```
+
+All of this is to say that creating custom signal pairs can be tedious.
+Below is an example showing the complexity involved.
 
 ```ts
 const [ count, setCount ] = createSignal(0);
@@ -56,40 +96,49 @@ const [ double, setDouble ] = [
 	createMemo(() => count() * 2),
 	
 	// The setter
-	(value: number | ((prev: number) => number)) => {
+	(newValue: number | ((prev: number) => number)) => {
 		
-		// Possibility of a function must be explicitly handled.
-		const newValue = (typeof value === "function") ? value(double()) : value;
+		// The function case must be handled.
+		const unwrappedNewValue = (typeof newValue === "function") ? newValue(untrack(double)) : newValue;
 		
-		setCount(newValue / 2);
+		setCount(unwrappedNewValue / 2);
 		
 		// And the result must be returned.
-		return newValue;
+		return unwrappedNewValue;
 	},
 ];
+```
 
-// Both of the below work, as a signal should.
-setDouble(10);         // double: 10, count: 5
-setDouble(x => x + 1); // double: 11, count: 5.5
+With that, the following statements work (as is expected of a setter):
+
+```ts
+setDouble(10);              // double: 10, count: 5
+setDouble(x => x + 1);      // double: 11, count: 5.5
+console.log(setDouble(20)); // Prints: 20
 ```
 
-Wouldn't it be convenient if we didn't have to handle all of that extra fluff though?
+But, the crusty boilerplate to get it working is annoying as heck.
 
-Enter co-signals. `Cosignal` is a getter setter pair like `Signal`, except that the setter doesn't accept a mapping function nor return a value. The `createCouple` function accepts a co-signal as input.
+**Enter the `createCouple` utility.**
+
+It accepts a getter and a co-setter and returns a signal.
+A co-setter is similar to a setter, except that it doesn't take a function nor does it return a value.
+Basically, it's the previous example without the boilerplate.
+See it in action:
 
 ```ts
 const [ count, setCount ] = createSignal(0);
 
-const [ double, setDouble ] = createCouple([
+const [ double, setDouble ] = createCouple(
 	() => count() * 2,
 	
-	(x) => {
-		// Notice how we don't need to handle `x` being a function here.
-		setCount(x / 2);
+	(newValue) => {
+		// Notice how we don't need to handle `newValue` being a function here.
+		setCount(newValue / 2);
 		
-		// Nor do we need to return the result.
+		// Nor do we need to return anything.
 	},
-]);
+);
 
 // Yet, we can still pass a function in.
 setDouble(x => x + 2);
@@ -99,16 +148,31 @@ console.log(double(), count()); // 2 1
 console.log(setDouble(10), count()); // 10 5
 ```
 
-The `createCouple` function transforms a co-signal into a signal. In what way?
-1. The getter is memoized for you.
-2. The setter is wrapped so that if a function is passed in, it is evaluated with the current value and then forwarded to the cosignal's setter, returning the latest result.
+Much better, right?
+
+> [!NOTE]
+> The getter passed to `createCouple` is always [memoized](https://docs.solidjs.com/concepts/derived-values/memos).
+> This immediately invokes the getter, so keep that in mind.
 
-The signal returned by `createCouple` can also be wrapped with `atom` to combine the getter and setter into one.
+By the way! A `createCouple` call, like any expression that evaluates to a signal, can be converted into an atom so that the getter and setter are merged into one.
 
 ```ts
 const double = atom(createCouple(/* ... */));
 ```
 
----
+## Atomic couples (`apair`)
+
+Similar to [atomic signals](#atomic-signals-asig), wrapping a `createCouple` call with `atom` is a common enough pattern to warrant a shorthand: `apair`.
+
+```ts
+const double = apair(() => count() * 2, (double) => count(double / 2));
+// is short for
+const double = atom(createCouple(() => count() * 2, (double) => count(double / 2)));
+```
+
+# Conclusion
+
+Perhaps you can see the power of the above primitives.
+Not only in what they do, but also in how they combine.
 
-Perhaps you can see the power of the above primitives. Not only in what they can do on their own, but also in what they can do when combined.
+More utilities for this library are in the works and will be coming soon.

package/dist/atom.d.ts

@@ -1,4 +1,4 @@
-import { type Signal, type SignalOptions } from "solid-js";
+import { type Accessor, type Signal, type SignalOptions } from "solid-js";
 /**
  * Any tuple of two functions where the first accepts no arguments and the second accepts any amount.
  */
@@ -32,7 +32,27 @@ export type Atom<T extends SignalLike = SignalLike> = T[0] & T[1];
  * count(count() + 1);
  * ```
  */
-export declare function atom<const T extends SignalLike>(value: T): Atom<T>;
+export declare function atom<const T extends SignalLike>(signal: T): Atom<T>;
+/**
+ * Similar to a signal setter, except it doesn't accept a mapping function nor return a result.
+ */
+export type Cosetter<T> = (value: T) => void;
+/**
+ * Create a signal from a cosignal.
+ *
+ * ### Example
+ * ```
+ * const [ count, setCount ] = createSignal(0);
+ * const [ double, setDouble ] = createSignalPair([
+ * 	() => count() * 2,
+ * 	(x) => void setCount(x / 2),
+ * ]);
+ *
+ * double(x => x + 2);
+ * console.log(double(), count()); // 2 1
+ * ```
+ */
+export declare function createCouple<T>(getter: Accessor<T>, setter: Cosetter<T>): Signal<T>;
 /**
  * An atomic signal.
  * A signal where the getter and setter are combined into one function.
@@ -40,7 +60,7 @@ export declare function atom<const T extends SignalLike>(value: T): Atom<T>;
 export type Asig<T> = Atom<Signal<T>>;
 /**
  * Create an atomic signal.
- * Shorthand for `atom(createSignal(...))`.
+ * Short for `atom(createSignal(...))`.
  *
  * ### Example
  * ```
@@ -53,32 +73,23 @@ export type Asig<T> = Atom<Signal<T>>;
  * console.log(count()); // 20
  * ```
  */
-export declare function asig<T>(): Atom<Signal<T | undefined>>;
-export declare function asig<T>(value: T, options?: SignalOptions<T>): Atom<Signal<T>>;
-/**
- * A getter setter pair.
- * While similar to `Signal`, the setter of
- *  `Cosignal` does not accept a mapping function;
- *  nor does it return a result.
- */
-export type Cosignal<T> = [
-    () => T,
-    (value: T) => void
-];
+export declare function asig<T>(): Asig<T | undefined>;
+export declare function asig<T>(value: T, options?: SignalOptions<T>): Asig<T>;
 /**
- * Create a signal from a cosignal.
+ * Create an atomic cosignal pair.
+ * Short for `atom(createCouple(...))`.
  *
  * ### Example
  * ```
- * const [ count, setCount ] = createSignal(0);
- * const [ double, setDouble ] = createSignalPair([
- * 	() => count() * 2,
- * 	(x) => void setCount(x / 2),
- * ]);
+ * const count = asig(0);
+ * const double = apair(() => count() * 2, (double) => void count(double / 2));
  *
- * double(x => x + 2);
- * console.log(double(), count()); // 2 1
+ * count(10);
+ * console.log(count(), double()); // 10 20
+ *
+ * double(100);
+ * console.log(count(), double()); // 50 100
  * ```
  */
-export declare function createCouple<T>(cosignal: Cosignal<T>): Signal<T>;
+export declare function apair<T>(getter: Accessor<T>, setter: Cosetter<T>): Asig<T>;
 //# sourceMappingURL=atom.d.ts.map

package/dist/atom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atom.d.ts","sourceRoot":"","sources":["../src/atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAG3G;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,CAAE,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAE,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAmBpE;;;GAGG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;AACvD,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAK/E;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACzB,MAAM,CAAC;IACP,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI;CAClB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAqBhE"}
+{"version":3,"file":"atom.d.ts","sourceRoot":"","sources":["../src/atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqC,KAAK,QAAQ,EAAe,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC;AAK1H;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,CAAE,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAE,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,IAAI,CAAC,KAAK,CAAC,CAAC,SAAS,UAAU,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAiBnE;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAmBnF;AAID;;;GAGG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,IAAI,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAC/C,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAKvE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAE1E"}

package/dist/atom.js

@@ -1,23 +1,42 @@
 import { createMemo, createSignal, untrack } from "solid-js";
 import { isDev } from "solid-js/web";
-export function atom(value) {
+/**
+ * Combine a getter and setter function pair into one.
+ *
+ * Accepts a tuple of two functions.
+ * The first is the getter, the second is the setter.
+ * A new function is returned that, when called with zero arguments, calls the getter.
+ * Otherwise, it calls the setter and forwards all of the arguments.
+ *
+ * ### Example
+ * ```
+ * const count = atom(createSignal(0));
+ *
+ * // Read
+ * count();
+ *
+ * // Write
+ * count(100);
+ * count(x => x + 1);
+ * count(count() + 1);
+ * ```
+ */
+export function atom(signal) {
     if (isDev) {
         // Assert that the input is valid.
         // For production, these checks are skipped for performance.
-        if (!Array.isArray(value)) {
-            throw new Error(`expected a getter setter pair as an array, but got ${typeof value}`);
+        if (!Array.isArray(signal)) {
+            throw new Error(`expected a getter setter pair as an array, but got ${typeof signal}`);
         }
-        if (typeof value[0] !== "function") {
-            throw new Error(`expected a getter function, but got ${typeof value[0]}`);
+        if (typeof signal[0] !== "function") {
+            throw new Error(`expected a getter function, but got ${typeof signal[0]}`);
         }
-        if (typeof value[1] !== "function") {
-            throw new Error(`expected a setter function, but got ${typeof value[1]}`);
+        if (typeof signal[1] !== "function") {
+            throw new Error(`expected a setter function, but got ${typeof signal[1]}`);
         }
     }
-    return (...args) => (args.length === 0) ? value[0]() : value[1](...args);
-}
-export function asig(value, options) {
-    return atom(createSignal(value, options));
+    const [getter, setter] = signal;
+    return (...args) => (args.length === 0) ? getter() : setter(...args);
 }
 /**
  * Create a signal from a cosignal.
@@ -34,25 +53,45 @@ export function asig(value, options) {
  * console.log(double(), count()); // 2 1
  * ```
  */
-export function createCouple(cosignal) {
+export function createCouple(getter, setter) {
     if (isDev) {
         // Assert that the input is valid.
         // For production, these checks are skipped for performance.
-        if (!Array.isArray(cosignal)) {
-            throw new Error(`expected a getter setter pair as an array, but got ${typeof cosignal}`);
-        }
-        if (typeof cosignal[0] !== "function") {
-            throw new Error(`expected a getter function, but got ${typeof cosignal[0]}`);
+        if (typeof getter !== "function") {
+            throw new Error(`expected getter to be a function, but got ${typeof getter}`);
         }
-        if (typeof cosignal[1] !== "function") {
-            throw new Error(`expected a setter function, but got ${typeof cosignal[1]}`);
+        if (typeof setter !== "function") {
+            throw new Error(`expected setter to be a function, but got ${typeof setter}`);
         }
     }
-    const get = createMemo(cosignal[0]);
-    const set = ((value) => {
-        cosignal[1]((typeof value === "function") ? value(untrack(get)) : value);
-        return untrack(get);
+    const get = createMemo(getter);
+    const set = ((source) => {
+        const value = (typeof source === "function") ? source(untrack(get)) : source;
+        setter(value);
+        return value;
     });
     return [get, set];
 }
+export function asig(value, options) {
+    return atom(createSignal(value, options));
+}
+/**
+ * Create an atomic cosignal pair.
+ * Short for `atom(createCouple(...))`.
+ *
+ * ### Example
+ * ```
+ * const count = asig(0);
+ * const double = apair(() => count() * 2, (double) => void count(double / 2));
+ *
+ * count(10);
+ * console.log(count(), double()); // 10 20
+ *
+ * double(100);
+ * console.log(count(), double()); // 50 100
+ * ```
+ */
+export function apair(getter, setter) {
+    return atom(createCouple(getter, setter));
+}
 //# sourceMappingURL=atom.js.map

package/dist/atom.js.map

@@ -1 +1 @@
-{"version":3,"file":"atom.js","sourceRoot":"","sources":["../src/atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAAgD,MAAM,UAAU,CAAC;AAC3G,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAsCrC,MAAM,UAAU,IAAI,CAAC,KAAc;IAClC,IAAI,KAAK,EAAE,CAAC;QACX,kCAAkC;QAClC,4DAA4D;QAE5D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,sDAAsD,OAAO,KAAK,EAAE,CAAC,CAAC;QACvF,CAAC;QACD,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACpC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC3E,CAAC;IACF,CAAC;IACD,OAAO,CAAC,GAAG,IAAS,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAE,KAAa,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAE,KAAa,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AACjG,CAAC;AAyBD,MAAM,UAAU,IAAI,CAAI,KAAqB,EAAE,OAAsC;IACpF,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;AAC3C,CAAC;AAaD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAI,QAAqB;IACpD,IAAI,KAAK,EAAE,CAAC;QACX,kCAAkC;QAClC,4DAA4D;QAE5D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,sDAAsD,OAAO,QAAQ,EAAE,CAAC,CAAC;QAC1F,CAAC;QACD,IAAI,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,OAAO,QAAQ,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACvC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;IACF,CAAC;IACD,MAAM,GAAG,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACtB,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,KAAK,UAAU,CAAC,CAAC,CAAC,CAAE,KAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAClF,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC;IACrB,CAAC,CAAc,CAAC;IAChB,OAAO,CAAE,GAAG,EAAE,GAAG,CAAW,CAAC;AAC9B,CAAC"}
+{"version":3,"file":"atom.js","sourceRoot":"","sources":["../src/atom.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,OAAO,EAA+D,MAAM,UAAU,CAAC;AAC1H,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAkBrC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,IAAI,CAA6B,MAAS;IACzD,IAAI,KAAK,EAAE,CAAC;QACX,kCAAkC;QAClC,4DAA4D;QAE5D,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,sDAAsD,OAAO,MAAM,EAAE,CAAC,CAAC;QACxF,CAAC;QACD,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC5E,CAAC;QACD,IAAI,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE,CAAC;YACrC,MAAM,IAAI,KAAK,CAAC,uCAAuC,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC5E,CAAC;IACF,CAAC;IACD,MAAM,CAAE,MAAM,EAAE,MAAM,CAAE,GAAG,MAAM,CAAC;IAClC,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;AACjF,CAAC;AAOD;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CAAI,MAAmB,EAAE,MAAmB;IACvE,IAAI,KAAK,EAAE,CAAC;QACX,kCAAkC;QAClC,4DAA4D;QAE5D,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,6CAA6C,OAAO,MAAM,EAAE,CAAC,CAAC;QAC/E,CAAC;QACD,IAAI,OAAO,MAAM,KAAK,UAAU,EAAE,CAAC;YAClC,MAAM,IAAI,KAAK,CAAC,6CAA6C,OAAO,MAAM,EAAE,CAAC,CAAC;QAC/E,CAAC;IACF,CAAC;IACD,MAAM,GAAG,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC;IAC/B,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;QACvB,MAAM,KAAK,GAAG,CAAC,OAAO,MAAM,KAAK,UAAU,CAAC,CAAC,CAAC,CAAE,MAAmB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC3F,MAAM,CAAC,KAAK,CAAC,CAAC;QACd,OAAO,KAAK,CAAC;IACd,CAAC,CAAc,CAAC;IAChB,OAAO,CAAE,GAAG,EAAE,GAAG,CAAW,CAAC;AAC9B,CAAC;AA2BD,MAAM,UAAU,IAAI,CAAI,KAAqB,EAAE,OAAsC;IACpF,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,KAAK,CAAI,MAAmB,EAAE,MAAmB;IAChE,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAC3C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-state-tools",
-  "version": "1.1.2",
+  "version": "1.3.1",
   "description": "A collection of Solid JS state utilities",
   "author": "Reed Syllas <reedsyllas@gmail.com>",
   "license": "ISC",
@@ -10,6 +10,8 @@
   },
   "homepage": "https://github.com/ReedSyllas/solid-state-tools#readme",
   "keywords": [
+    "atom",
+    "signal",
     "solid",
     "state"
   ],