solid-state-tools 1.1.1 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. package/README.md +92 -39
  2. package/dist/atom.d.ts +34 -23
  3. package/dist/atom.d.ts.map +1 -1
  4. package/dist/atom.js +32 -15
  5. package/dist/atom.js.map +1 -1
  6. package/package.json +3 -1
package/README.md CHANGED
@@ -1,16 +1,31 @@
1
- # Solid JS State Tools
1
+ # Solid State Tools
2
2
 
3
- This is a collection of simple utilities for managing [Solid JS](https://docs.solidjs.com/) state.
4
- It is intended to compliment Solid JS's existing state system, not replace it.
3
+ Solid State Tools is a collection of simple utilities for managing [Solid JS](https://docs.solidjs.com/) state.
5
4
 
6
- This package is tiny and only has a peer dependency of Solid JS.
5
+ All features are intended to compliment Solid JS's existing state system, building upon the existing foundation.
6
+
7
+ The package is small and only has a peer dependency of Solid JS.
8
+
9
+ # Usage
10
+
11
+ This library introduces some new primitives:
12
+
13
+ 1. [atom](#atoms-atom)
14
+ 2. [createCouple](#couples-createcouple)
15
+
16
+ And, a few shorthand functions that combine these primitives and those from Solid JS together.
17
+
18
+ 1. [asig](#atomic-signals-asig)
19
+ 2. [apair](#atomic-couples-apair)
20
+
21
+ Read the sections below for a breakdown of each utility.
7
22
 
8
23
  ## Atoms (`atom`)
9
24
 
10
25
  Atoms combine the getter and setter of a [signal](https://docs.solidjs.com/concepts/signals) into one function.
11
26
 
12
27
  ```ts
13
- const count = atom(createSignal(0));
28
+ const count: Atom<Signal<number>> = atom(createSignal(0));
14
29
 
15
30
  console.log(count()); // 0
16
31
 
@@ -24,29 +39,44 @@ count((c) => c + 1);
24
39
  console.log(count()); // 102
25
40
  ```
26
41
 
27
- 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.
42
+ When called with no arguments, the atom acts like the signal's getter.
43
+ 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.
28
44
 
29
- 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.
45
+ Atoms simplify the boilerplate that comes with managing separate getters and setters.
46
+ However, signals are still preferred when granular control of the getter and setter is needed.
47
+ Additionally, atoms incur a tiny performance cost. Thus, atoms do not replace signals. They coexist.
30
48
 
31
49
  ## Atomic signals (`asig`)
32
50
 
33
- Because creating and wrapping a signal with `atom` is so common, a shorthand utility was created called `asig` (atomic signal).
51
+ Creating a signal and immediately 'atomizing' it is a common pattern. The `asig` function was created for this, along with its related type `Asig`.
34
52
 
35
53
  ```ts
36
- const count = asig(0);
37
- // is a shorthand for
38
- const count = atom(createSignal(0));
54
+ const count: Asig<number> = asig(0);
55
+ // is short for
56
+ const count: Atom<Signal<number>> = atom(createSignal(0));
39
57
  ```
40
58
 
41
- ## Co-signals (`createCouple`)
59
+ ## Couples (`createCouple`)
42
60
 
43
- 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.
61
+ A signal can be summarized as a getter setter pair.
62
+ However, the setter of a Solid JS signal is more complex than it appears at first glance.
63
+ Why?
44
64
 
45
- ```ts
46
- setCount(x => x + 1);
47
- ```
65
+ 1. It accepts a function which transforms the previous value into the new one.
66
+ ```ts
67
+ setCount(x => x + 1);
68
+ ```
48
69
 
49
- 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.
70
+ 2. It also returns the value.
71
+ ```ts
72
+ const [ _count, setCount ] = createSignal(0);
73
+
74
+ console.log(setCount(10)); // Prints: 10
75
+ console.log(setCount(x => x + 5)); // Prints: 15
76
+ ```
77
+
78
+ All of this is to say that creating custom signal pairs can be tedious.
79
+ Below is an example showing the complexity involved.
50
80
 
51
81
  ```ts
52
82
  const [ count, setCount ] = createSignal(0);
@@ -56,40 +86,48 @@ const [ double, setDouble ] = [
56
86
  createMemo(() => count() * 2),
57
87
 
58
88
  // The setter
59
- (value: number | ((prev: number) => number)) => {
89
+ (newValue: number | ((prev: number) => number)) => {
60
90
 
61
- // Possibility of a function must be explicitly handled.
62
- const newValue = (typeof value === "function") ? value(double()) : value;
91
+ // The function case must be handled.
92
+ const unwrappedNewValue = (typeof newValue === "function") ? newValue(untrack(double)) : newValue;
63
93
 
64
- setCount(newValue / 2);
94
+ setCount(unwrappedNewValue / 2);
65
95
 
66
96
  // And the result must be returned.
67
- return newValue;
97
+ return unwrappedNewValue;
68
98
  },
69
99
  ];
100
+ ```
101
+
102
+ With that, all of the statements below work exactly as expected.
70
103
 
71
- // Both of the below work, as a signal should.
72
- setDouble(10); // double: 10, count: 5
73
- setDouble(x => x + 1); // double: 11, count: 5.5
104
+ ```ts
105
+ setDouble(10); // double: 10, count: 5
106
+ setDouble(x => x + 1); // double: 11, count: 5.5
107
+ console.log(setDouble(20)); // Prints: 20
74
108
  ```
75
109
 
76
- Wouldn't it be convenient if we didn't have to handle all of that extra fluff though?
110
+ But, wouldn't it be convenient if we could skip the crusty boilerplate?
77
111
 
78
- 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.
112
+ **Enter the `createCouple` utility**
113
+
114
+ It accepts a getter and a co-setter and returns a signal.
115
+ A co-setter is similar to a setter, except that it doesn't take a function nor does it return a value.
116
+ Basically, it's the previous example without the boilerplate. See the following example:
79
117
 
80
118
  ```ts
81
119
  const [ count, setCount ] = createSignal(0);
82
120
 
83
- const [ double, setDouble ] = createCouple([
121
+ const [ double, setDouble ] = createCouple(
84
122
  () => count() * 2,
85
123
 
86
- (x) => {
87
- // Notice how we don't need to handle `x` being a function here.
88
- setCount(x / 2);
124
+ (newValue) => {
125
+ // Notice how we don't need to handle `newValue` being a function here.
126
+ setCount(newValue / 2);
89
127
 
90
- // Nor do we need to return the result.
128
+ // Nor do we need to return anything.
91
129
  },
92
- ]);
130
+ );
93
131
 
94
132
  // Yet, we can still pass a function in.
95
133
  setDouble(x => x + 2);
@@ -99,16 +137,31 @@ console.log(double(), count()); // 2 1
99
137
  console.log(setDouble(10), count()); // 10 5
100
138
  ```
101
139
 
102
- The `createCouple` function transforms a co-signal into a signal. In what way?
103
- 1. The getter is memoized for you.
104
- 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.
140
+ Much better, right?
141
+
142
+ > [!NOTE]
143
+ > The getter passed to `createCouple` is always memoized.
144
+ > This has the consequence that the getter is invoked immediately during creation of the couple.
105
145
 
106
- The signal returned by `createCouple` can also be wrapped with `atom` to combine the getter and setter into one.
146
+ 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.
107
147
 
108
148
  ```ts
109
149
  const double = atom(createCouple(/* ... */));
110
150
  ```
111
151
 
112
- ---
152
+ ## Atomic couples (`apair`)
153
+
154
+ Similar to [atomic signals](#atomic-signals-asig), wrapping a `createCouple` call with `atom` is a common enough pattern to warrant a shorthand: `apair`.
155
+
156
+ ```ts
157
+ const double = apair(() => count() * 2, (double) => count(double / 2));
158
+ // is short for
159
+ const double = atom(createCouple(() => count() * 2, (double) => count(double / 2)));
160
+ ```
161
+
162
+ # Conclusion
163
+
164
+ Perhaps you can see the power of the above primitives.
165
+ Not only in what they do, but also in how they combine.
113
166
 
114
- 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.
167
+ More utilities for this library are in the works and will be coming soon.
package/dist/atom.d.ts CHANGED
@@ -1,4 +1,4 @@
1
- import { type Signal, type SignalOptions } from "solid-js";
1
+ import { type Accessor, type Signal, type SignalOptions } from "solid-js";
2
2
  /**
3
3
  * Any tuple of two functions where the first accepts no arguments and the second accepts any amount.
4
4
  */
@@ -33,6 +33,26 @@ export type Atom<T extends SignalLike = SignalLike> = T[0] & T[1];
33
33
  * ```
34
34
  */
35
35
  export declare function atom<const T extends SignalLike>(value: T): Atom<T>;
36
+ /**
37
+ * Similar to a signal setter, except it doesn't accept a mapping function nor return a result.
38
+ */
39
+ export type Cosetter<T> = (value: T) => void;
40
+ /**
41
+ * Create a signal from a cosignal.
42
+ *
43
+ * ### Example
44
+ * ```
45
+ * const [ count, setCount ] = createSignal(0);
46
+ * const [ double, setDouble ] = createSignalPair([
47
+ * () => count() * 2,
48
+ * (x) => void setCount(x / 2),
49
+ * ]);
50
+ *
51
+ * double(x => x + 2);
52
+ * console.log(double(), count()); // 2 1
53
+ * ```
54
+ */
55
+ export declare function createCouple<T>(getter: Accessor<T>, setter: Cosetter<T>): Signal<T>;
36
56
  /**
37
57
  * An atomic signal.
38
58
  * 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>;
40
60
  export type Asig<T> = Atom<Signal<T>>;
41
61
  /**
42
62
  * Create an atomic signal.
43
- * Shorthand for `atom(createSignal(...))`.
63
+ * Short for `atom(createSignal(...))`.
44
64
  *
45
65
  * ### Example
46
66
  * ```
@@ -53,32 +73,23 @@ export type Asig<T> = Atom<Signal<T>>;
53
73
  * console.log(count()); // 20
54
74
  * ```
55
75
  */
56
- export declare function asig<T>(): Atom<Signal<T | undefined>>;
57
- export declare function asig<T>(value: T, options?: SignalOptions<T>): Atom<Signal<T>>;
58
- /**
59
- * A getter setter pair.
60
- * While similar to `Signal`, the setter of
61
- * `Cosignal` does not accept a mapping function;
62
- * nor does it return a result.
63
- */
64
- export type Cosignal<T> = [
65
- () => T,
66
- (value: T) => void
67
- ];
76
+ export declare function asig<T>(): Asig<T | undefined>;
77
+ export declare function asig<T>(value: T, options?: SignalOptions<T>): Asig<T>;
68
78
  /**
69
- * Create a signal from a cosignal.
79
+ * Create an atomic cosignal pair.
80
+ * Short for `atom(createCouple(...))`.
70
81
  *
71
82
  * ### Example
72
83
  * ```
73
- * const [ count, setCount ] = createSignal(0);
74
- * const [ double, setDouble ] = createSignalPair([
75
- * () => count() * 2,
76
- * (x) => void setCount(x / 2),
77
- * ]);
84
+ * const count = asig(0);
85
+ * const double = apair(() => count() * 2, (double) => void count(double / 2));
78
86
  *
79
- * double(x => x + 2);
80
- * console.log(double(), count()); // 2 1
87
+ * count(10);
88
+ * console.log(count(), double()); // 10 20
89
+ *
90
+ * double(100);
91
+ * console.log(count(), double()); // 50 100
81
92
  * ```
82
93
  */
83
- export declare function createCouple<T>(cosignal: Cosignal<T>): Signal<T>;
94
+ export declare function apair<T>(getter: Accessor<T>, setter: Cosetter<T>): Asig<T>;
84
95
  //# sourceMappingURL=atom.d.ts.map
package/dist/atom.d.ts.map CHANGED
@@ -1 +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"}
1
+ {"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,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAmBpE;;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 CHANGED
@@ -16,9 +16,6 @@ export function atom(value) {
16
16
  }
17
17
  return (...args) => (args.length === 0) ? value[0]() : value[1](...args);
18
18
  }
19
- export function asig(value, options) {
20
- return atom(createSignal(value, options));
21
- }
22
19
  /**
23
20
  * Create a signal from a cosignal.
24
21
  *
@@ -34,25 +31,45 @@ export function asig(value, options) {
34
31
  * console.log(double(), count()); // 2 1
35
32
  * ```
36
33
  */
37
- export function createCouple(cosignal) {
34
+ export function createCouple(getter, setter) {
38
35
  if (isDev) {
39
36
  // Assert that the input is valid.
40
37
  // For production, these checks are skipped for performance.
41
- if (!Array.isArray(cosignal)) {
42
- throw new Error(`expected a getter setter pair as an array, but got ${typeof cosignal}`);
43
- }
44
- if (typeof cosignal[0] !== "function") {
45
- throw new Error(`expected a getter function, but got ${typeof cosignal[0]}`);
38
+ if (typeof getter !== "function") {
39
+ throw new Error(`expected getter to be a function, but got ${typeof getter}`);
46
40
  }
47
- if (typeof cosignal[1] !== "function") {
48
- throw new Error(`expected a setter function, but got ${typeof cosignal[1]}`);
41
+ if (typeof setter !== "function") {
42
+ throw new Error(`expected setter to be a function, but got ${typeof setter}`);
49
43
  }
50
44
  }
51
- const get = createMemo(cosignal[0]);
52
- const set = ((value) => {
53
- cosignal[1]((typeof value === "function") ? value(untrack(get)) : value);
54
- return get();
45
+ const get = createMemo(getter);
46
+ const set = ((source) => {
47
+ const value = (typeof source === "function") ? source(untrack(get)) : source;
48
+ setter(value);
49
+ return value;
55
50
  });
56
51
  return [get, set];
57
52
  }
53
+ export function asig(value, options) {
54
+ return atom(createSignal(value, options));
55
+ }
56
+ /**
57
+ * Create an atomic cosignal pair.
58
+ * Short for `atom(createCouple(...))`.
59
+ *
60
+ * ### Example
61
+ * ```
62
+ * const count = asig(0);
63
+ * const double = apair(() => count() * 2, (double) => void count(double / 2));
64
+ *
65
+ * count(10);
66
+ * console.log(count(), double()); // 10 20
67
+ *
68
+ * double(100);
69
+ * console.log(count(), double()); // 50 100
70
+ * ```
71
+ */
72
+ export function apair(getter, setter) {
73
+ return atom(createCouple(getter, setter));
74
+ }
58
75
  //# sourceMappingURL=atom.js.map
package/dist/atom.js.map CHANGED
@@ -1 +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,GAAG,EAAE,CAAC;IACd,CAAC,CAAc,CAAC;IAChB,OAAO,CAAE,GAAG,EAAE,GAAG,CAAW,CAAC;AAC9B,CAAC"}
1
+ {"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;AAwCrC,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,IAAe,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAE,KAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAE,KAAoB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;AACrH,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 CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "solid-state-tools",
3
- "version": "1.1.1",
3
+ "version": "1.3.0",
4
4
  "description": "A collection of Solid JS state utilities",
5
5
  "author": "Reed Syllas <reedsyllas@gmail.com>",
6
6
  "license": "ISC",
@@ -10,6 +10,8 @@
10
10
  },
11
11
  "homepage": "https://github.com/ReedSyllas/solid-state-tools#readme",
12
12
  "keywords": [
13
+ "atom",
14
+ "signal",
13
15
  "solid",
14
16
  "state"
15
17
  ],