solid-state-tools 1.5.1 → 1.6.0

package/README.md

@@ -6,16 +6,17 @@ Solid State Tools is a collection of simple utilities for managing [Solid JS](ht
 
 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.
+The package is small and the only production dependency is Solid JS.
 
 # Usage
 
-| Utility                         | Summary                                          |
-| ------------------------------- | ------------------------------------------------ |
-| [atom](#atoms-atom)             | Combines a getter setter pair into one function. |
-| [createPair](#pairs-createpair) | Creates a signal from a getter setter pair.      |
-| [asig](#atomic-signals-asig)    | Shorthand for `atom(createSignal(...))`          |
-| [apair](#atomic-pairs-apair)    | Shorthand for `atom(createCouple(...))`          |
+| Utility                                  | Summary                                           |
+| ---------------------------------------- | ------------------------------------------------- |
+| [atom](#atoms-atom)                      | Combines a getter setter pair into one function.  |
+| [createPair](#pairs-createpair)          | Creates a signal from a getter setter pair.       |
+| [asig](#atomic-signals-asig)             | Shorthand for `atom(createSignal(...))`           |
+| [apair](#atomic-pairs-apair)             | Shorthand for `atom(createCouple(...))`           |
+| [createBlinker](#blinkers-createblinker) | Creates a reactive boolean for flashing elements. |
 
 Read the sections below for a breakdown of each utility.
 
@@ -180,9 +181,25 @@ const double = apair(() => count() * 2, (double) => count(double / 2));
 const double = atom(createPair(() => count() * 2, (double) => count(double / 2)));
 ```
 
+## Blinkers (`createBlinker`)
+
+A blinker is a reactive boolean that tracks some state. When the state updates, the blinker temporarily flips to true.
+
+This is primarily useful for flashing an element on the page when a signal changes to draw the user's attention to it.
+
+```tsx
+const [ count, setCount ] = createSignal(0);
+const countBlinked = createBlinker(count, 200);
+
+// Flashes orange for 200ms when count changes.
+<span style={ { "color": countBlinked() ? "orange" : undefined } }>
+	{ count() }
+</span>
+```
+
 # Conclusion
 
 Perhaps you can see the power of the above primitives.
-Not just what they do individually, but how they work together.
+Specifically, how they work together to reduce boilerplate.
 
 More utilities for this library are in the works and are coming soon.

package/dist/index.js

@@ -1,106 +1,147 @@
-import { createMemo, createSignal, untrack } from "solid-js";
-import { isDev } from "solid-js/web";
-/**
- * @description
- * Combine a getter and setter function pair into one.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atoms-atom)
- *
- * 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.
- *
- * @see {@link SignalLike} (input), {@link Atom} (output)
- *
- * @example
- * ```
- * const count: Atom<Signal<T>> = 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(signal)) {
-            throw new Error(`expected a getter setter pair as an array, but got ${typeof signal}`);
-        }
-        if (typeof signal[0] !== "function") {
-            throw new Error(`expected a getter function, but got ${typeof signal[0]}`);
-        }
-        if (typeof signal[1] !== "function") {
-            throw new Error(`expected a setter function, but got ${typeof signal[1]}`);
-        }
-    }
-    const [getter, setter] = signal;
-    return (...args) => (args.length === 0) ? getter() : setter(...args);
+import { createMemo as E, createSignal as s, createComputed as w, on as $, getOwner as L, createSelector as O, onCleanup as x, batch as m, getListener as k, untrack as a, runWithOwner as C, createRoot as F } from "solid-js";
+import { isDev as g } from "solid-js/web";
+function h(t) {
+  if (g) {
+    if (!Array.isArray(t))
+      throw new Error(`expected signal to be an array, but got ${typeof t}`);
+    if (typeof t[0] != "function")
+      throw new Error(`expected getter to be a function, but got ${typeof t[0]}`);
+    if (typeof t[1] != "function")
+      throw new Error(`expected setter to be a function, but got ${typeof t[1]}`);
+  }
+  const [e, r] = t;
+  return Object.assign(
+    (...o) => o.length === 0 ? e() : r(...o),
+    e,
+    r
+  );
 }
-/**
- * @description
- * Create a signal from a getter setter pair.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#pairs-createpair)
- *
- * **The getter is immediately invoked for memoization.**
- *
- * @see {@link Accessor} (input), {@link Writer} (input), {@link PairOptions} (input), {@link Signal} (output)
- *
- * @example
- * ```
- * const [ count, setCount ] = createSignal(0);
- * const [ double, setDouble ] = createPair(() => count() * 2, (x) => setCount(x / 2));
- *
- * setDouble(x => x + 2);
- * console.log(double(), count()); // 2 1
- * ```
- */
-export function createPair(getter, setter, options) {
-    if (isDev) {
-        // Assert that the input is valid.
-        // For production, these checks are skipped for performance.
-        if (typeof getter !== "function") {
-            throw new Error(`expected getter to be a function, but got ${typeof getter}`);
-        }
-        if (typeof setter !== "function") {
-            throw new Error(`expected setter to be a function, but got ${typeof setter}`);
-        }
-    }
-    const get = options?.memoized === false ? getter : createMemo(getter);
-    const set = ((source) => {
-        const value = (typeof source === "function") ? source(untrack(get)) : source;
-        setter(value);
-        return value;
+function j(t, e, r) {
+  if (g) {
+    if (typeof t != "function")
+      throw new Error(`expected getter to be a function, but got ${typeof t}`);
+    if (typeof e != "function")
+      throw new Error(`expected setter to be a function, but got ${typeof e}`);
+  }
+  const o = r?.memoized === !1 ? t : E(t);
+  return [o, ((c) => {
+    const u = typeof c == "function" ? c(a(o)) : c;
+    return e(u), u;
+  })];
+}
+function R(t, e = 500) {
+  if (g) {
+    if (typeof t != "function")
+      throw new Error(`expected subject to be a function, but got ${typeof t}`);
+    if (typeof e != "number")
+      throw new Error(`expected duration to be a number, but got ${typeof e}`);
+  }
+  const [r, o] = s(!1);
+  let n;
+  return w($(t, () => {
+    n !== void 0 ? clearTimeout(n) : o(!0), n = setTimeout(() => {
+      o(!1), n = void 0;
+    }, e);
+  }, { defer: !0 })), r;
+}
+function q(t, e) {
+  const [r, o] = s(e?.initial), n = () => t((c) => o(() => c), r);
+  if (e?.late) {
+    const c = L();
+    let u = () => {
+      u = void 0, C(c, n);
+    };
+    return () => (u?.(), r());
+  }
+  return n(), r;
+}
+function T(t, e) {
+  const [r, o] = s(), [n, c] = s(e?.initial), [u, l] = s("unresolved"), p = O(u);
+  let d = !1;
+  const b = q((y, v) => {
+    w(() => {
+      let i = !1;
+      x(() => {
+        i = !0, y(void 0);
+      }), l(d ? "refreshing" : "pending");
+      try {
+        t((f) => {
+          i || m(() => {
+            l("ready"), c(() => f), d = !0, y(f);
+          });
+        }, v);
+      } catch (f) {
+        m(() => {
+          l("errored"), o(f);
+        });
+      }
     });
-    return [get, set];
+  }, e);
+  return Object.assign(b, {
+    error: r,
+    latest: n,
+    state: u,
+    is: p
+  });
+}
+function S(t, e) {
+  let r = 0, o;
+  const n = () => {
+    r === 0 && (o = a(e)), r++;
+  }, c = () => queueMicrotask(() => {
+    r--, r === 0 && (o?.(), o = void 0);
+  });
+  return () => (k() && (n(), x(c)), t());
+}
+function z(t, e) {
+  const [r, o] = s(a(t), e);
+  return S(r, () => F((n) => (w(() => {
+    o(t);
+  }), n)));
+}
+function B(t, e) {
+  const [r, o] = s(e?.initial);
+  let n = !!e?.initial;
+  const [c, u] = s(), [l, p] = s(!1), d = E(() => r() !== c()), b = (i) => m(() => {
+    const f = t.reconcile ? t.reconcile(i, a(r), a(c)) : i;
+    return n = !0, o(() => f), u(() => f), f;
+  }), y = h([
+    S(r, () => {
+      const i = t.sub(b);
+      return p(!0), () => {
+        p(!1), i();
+      };
+    }),
+    (...i) => (n = !0, o(...i))
+  ]);
+  return Object.assign(y, {
+    async pull() {
+      const i = await a(t.get);
+      return b(i);
+    },
+    async push() {
+      n && await t.set(a(r));
+    },
+    cache: c,
+    subscribed: l,
+    detached: d
+  });
 }
-export function asig(value, options) {
-    return atom(createSignal(value, options));
+function D(t, e) {
+  return h(s(t, e));
 }
-/**
- * @description
- * Create an atomic getter setter pair. Short for `atom(createPair(...))`.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atomic-pairs-apair)
- *
- * @see {@link Accessor} (input), {@link Writer} (input), {@link PairOptions} (input), {@link Asig} (output)
- *
- * @example
- * ```
- * const count = asig(0);
- * const double = apair(() => count() * 2, (x) => count(x / 2));
- *
- * count(10);
- * console.log(count(), double()); // 10 20
- *
- * double(100);
- * console.log(count(), double()); // 50 100
- * ```
- */
-export function apair(getter, setter, options) {
-    return atom(createPair(getter, setter, options));
+function P(t, e, r) {
+  return h(j(t, e, r));
 }
+export {
+  P as apair,
+  D as asig,
+  h as atom,
+  R as createBlinker,
+  T as createFetched,
+  j as createPair,
+  q as createSpool,
+  B as createSubscription,
+  z as derive,
+  S as quantum
+};

package/dist/types/index.d.ts

@@ -0,0 +1,347 @@
+import { Accessor, Setter, Signal, SignalOptions } from 'solid-js';
+/**
+ * A function that updates a state to the given value.
+ *
+ * @see {@link Setter} (related type)
+ */
+export type Update<T> = (value: T) => void;
+/**
+ * Any tuple of two functions where the first accepts no arguments and the second accepts any amount.
+ *
+ * Used as the source of an {@link Atom}.
+ *
+ * @see {@link Atom}, {@link atom}
+ */
+export type SignalLike = readonly [
+    getter: () => any,
+    setter: (...args: any) => any
+];
+/**
+ * An {@link Atom} is a polymorphic function that calls one of two
+ *  functions depending on the number of arguments it has.
+ *
+ * If called with zero arguments, the first function is called.
+ * Otherwise, the second function is called with all arguments forwarded to it.
+ *
+ * @see {@link SignalLike}, {@link atom} (constructor)
+ */
+export type Atom<T extends SignalLike = SignalLike> = T[0] & T[1];
+/**
+ * Combine a getter and setter function pair into one.
+ * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atoms-atom)
+ *
+ * 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.
+ *
+ * @see {@link SignalLike} (input), {@link Atom} (output)
+ *
+ * @example
+ * ```ts
+ * const count: Atom<Signal<T>> = atom(createSignal(0));
+ *
+ * // Read
+ * count();
+ *
+ * // Write
+ * count(100);
+ * count(x => x + 1);
+ * count(count() + 1);
+ * ```
+ */
+export declare function atom<const T extends SignalLike>(signal: T): Atom<T>;
+export interface PairOptions {
+    /**
+     * @default true
+     */
+    memoized: boolean;
+}
+/**
+ * Create a signal from a getter setter pair.
+ * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#pairs-createpair)
+ *
+ * **The getter is immediately invoked for memoization.**
+ *
+ * @see {@link Accessor} (input), {@link Update} (input), {@link PairOptions} (input), {@link Signal} (output)
+ *
+ * @example
+ * ```ts
+ * const [ count, setCount ] = createSignal(0);
+ * const [ double, setDouble ] = createPair(() => count() * 2, (x) => setCount(x / 2));
+ *
+ * setDouble(x => x + 2);
+ * console.log(double(), count()); // 2 1
+ * ```
+ */
+export declare function createPair<T>(getter: Accessor<T>, setter: Update<T>, options?: PairOptions): Signal<T>;
+/**
+ * Create a reactive boolean that temporarily flips to true when the subject changes value.
+ *
+ * Useful for flashing an element when a signal changes value.
+ * Perhaps to draw the user's attention to it.
+ *
+ * @param subject The subject to track for changes.
+ * @param duration The duration in milliseconds to "blink" before resetting to false. Default: 500.
+ *
+ * @see {@link Accessor}
+ *
+ * @example
+ * ```tsx
+ * const [ count, setCount ] = createSignal(0);
+ * const countBlinked = createBlinker(count, 200);
+ *
+ * <span style={ { "color": countBlinked() ? "orange" : undefined } }>
+ *   { count() }
+ * </span>
+ * ```
+ */
+export declare function createBlinker(subject: Accessor<unknown>, duration?: number): Accessor<boolean>;
+/**
+ * A function that will periodically call the given update function as needed.
+ * The current value (stateful) is also available to the consumer for incremental changes.
+ *
+ * @see {@link Update}, {@link Accessor}
+ */
+export type Winch<T, Initial extends T | undefined> = (update: Update<T>, value: Accessor<Initial>) => void;
+/**
+ * Options for creation of a spool signal.
+ *
+ * @see {@link createSpool}
+ */
+export interface SpoolOptions<T> {
+    /**
+     * The initial value of the spool signal.
+     * @default undefined
+     */
+    initial?: T;
+    /**
+     * If set to true, the winch will not be invoked until the spool signal is read for the first time.
+     * @default false
+     */
+    late?: boolean;
+}
+/**
+ * Create a signal from a winch.
+ *
+ * This is essentially an alternative way of writing a signal declaration.
+ *
+ * Note that the winch is not tracked and therefore does not automatically rerun when state changes.
+ * This behavior can be implemented in the winch function itself, if desired.
+ * Use {@link createFetched} for a reactive version.
+ *
+ * @see {@link Winch} (input), {@link SpoolOptions} (input), {@link Accessor} (output)
+ *
+ * @example
+ * ```tsx
+ * // A timer that updates each second.
+ * const time: Accessor<number> = createSpool((setTime, curr) => {
+ *   // Start timer.
+ *   const interval = setInterval(() => void setTime(curr() + 1), 1000);
+ *
+ *   // Dispose of timer when signal is destroyed.
+ *   onCleanup(() => void clearInterval(interval));
+ * }, {
+ *   initial: 0,
+ * });
+ *
+ * <div>
+ *   { time() }
+ * </div>
+ * ```
+ */
+export declare function createSpool<T>(winch: Winch<T, T>, options: SpoolOptions<T> & {
+    initial: T;
+}): Accessor<T>;
+export declare function createSpool<T>(winch: Winch<T, T | undefined>, options?: SpoolOptions<T>): Accessor<T | undefined>;
+/**
+ * A synchronous reactive state driven by a winch.
+ *
+ * @see {@link Accessor}, {@link Winch}, {@link createFetched} (constructor)
+ */
+export type Fetched<T> = Accessor<T> & FetchedMembers<T>;
+export interface FetchedMembers<T> {
+    error: Accessor<unknown>;
+    latest: Accessor<T>;
+    state: Accessor<FetchedState>;
+    is: (key: FetchedState) => boolean;
+}
+/**
+ * Represents the current state of a fetched signal.
+ *
+ * Its identical to {@link Resource.state} in meaning.
+ * See the [table of definitions](https://docs.solidjs.com/reference/basic-reactivity/create-resource#resource) for that.
+ *
+ * @see {@link Fetched.state}
+ */
+export type FetchedState = "unresolved" | "pending" | "ready" | "refreshing" | "errored";
+/**
+ * Create a signal that's driven by a tracked winch.
+ *
+ * The winch is tracked and therefore is rerun when its state changes.
+ *
+ * If the winch is rerun, the old winch can no longer mutate the state.
+ * This prevents race conditions where the old winch attempts to write _after_ the new winch resolved.
+ *
+ * @see {@link Winch} (input), {@link SpoolOptions} (input), {@link Fetched} (output)
+ */
+export declare function createFetched<T>(winch: Winch<T, T>, options: SpoolOptions<T> & {
+    initial: T;
+}): Fetched<T>;
+export declare function createFetched<T>(winch: Winch<T, T | undefined>, options?: SpoolOptions<T>): Fetched<T | undefined>;
+export type QuantumAccessor<T> = Accessor<T>;
+/**
+ * Create a quantum accessor.
+ *
+ * A quantum accessor counts its listeners and executes `track` if it is used at least once.
+ * When it is no longer used, `track`'s disposal function is invoked.
+ *
+ * Quantum accessors have standalone utility, but their primary purpose was to create and destroy subscriptions on the fly.
+ * Thus, {@link createSubscription} and {@link derive} replace most situations where {@link quantum} would be invoked directly.
+ *
+ * Note that quantum accessors count listeners ambiguously.
+ * Thus, some primitives must be substituted with a quantum-compatible one to preserve the 'quantum' behavior.
+ * Using a quantum accessor in these primitives (e.g. {@link createMemo}) is not _wrong_, but it may have unintended side-effects.
+ * Use {@link derive} in place of {@link createMemo} for quantum accessors.
+ *
+ * Technically, {@link QuantumAccessor} is just an alias of {@link Accessor} and can be used anywhere {@link Accessor} is allowed.
+ * However, it is useful to mark it this way due to the special handling (mentioned above) that's sometimes needed.
+ *
+ * @example
+ * ```ts
+ * const [ source ] = createSignal(0);
+ * const count = quantum(source, () => {
+ *   console.log("count is now observed");
+ *   return () => {
+ *     console.log("count is no longer observed");
+ *   };
+ * });
+ *
+ * createRoot((dispose) => {
+ *   count(); // nothing happens because `createRoot` doesn't track signals
+ *
+ *   createComputed(() => {
+ *     count(); // prints "count is now observed" because `createComputed` started tracking `count`
+ *     count(); // nothing happens because count is already tracked at least once
+ *   });
+ *
+ *   dispose(); // prints "count is no longer observed" because the `createComputed` is destroyed and `count` isn't tracked by anything else
+ * });
+ * ```
+ */
+export declare function quantum<T>(source: Accessor<T>, track: () => () => void): QuantumAccessor<T>;
+/**
+ * Derive a new quantum accessor from an existing one while preserving the quantum behavior.
+ *
+ * Essentially, this is a quantum-compatible version of {@link createMemo}.
+ *
+ * This provides no advantage over {@link createMemo} for traditional accessors.
+ *
+ * @see {@link quantum}, {@link QuantumAccessor}
+ *
+ * @example
+ * ```ts
+ * const count: QuantumAccessor<number> = ...;
+ * const double = derive(() => count() * 2);
+ * ```
+ */
+export declare function derive<T>(source: QuantumAccessor<T>, options?: SignalOptions<T>): QuantumAccessor<T>;
+/**
+ * Handler for a subscription.
+ *
+ * @see {@link Subscription}, {@link createSubscription}
+ */
+export type Subscribable<T, Initial extends T | undefined> = {
+    get: () => Promise<T>;
+    set: (value: T) => Promise<void>;
+    sub: (update: Update<T>) => () => void;
+    reconcile?: (remote: T, local: Initial, cache: T | undefined) => T;
+};
+/**
+ * A state driven by a remote subscription.
+ *
+ * @see {@link createSubscription} (constructor), {@link QuantumAccessor} (component type)
+ */
+export type Subscription<T> = QuantumAccessor<T> & Setter<T> & SubscriptionMembers<T>;
+export type SubscriptionMembers<T> = {
+    /**
+     * The last known remote value.
+     *
+     * It changes when a new remote value is pushed or pulled to this subscribable.
+     */
+    cache: Accessor<T | undefined>;
+    /**
+     * Fetch the remote value and reconcile it with the current value (local) and cache.
+     */
+    pull: () => Promise<T>;
+    /**
+     * Push local to the remote.
+     */
+    push: () => Promise<void>;
+    /**
+     * True if subscribed to the remote.
+     */
+    subscribed: Accessor<boolean>;
+    /**
+     * True if the current value (local) is different from the last known remote value (cache).
+     */
+    detached: Accessor<boolean>;
+};
+/**
+ * Options for creation of a subscription.
+ *
+ * @see {@link createSubscription}, {@link Subscription}
+ */
+export interface SubscriptionOptions<T> {
+    initial?: T;
+}
+/**
+ * Create a new subscription from a subscribable (handler).
+ *
+ * Quantum signals are used for dynamic subscription through observation.
+ */
+export declare function createSubscription<T>(handler: Subscribable<T, T | undefined>, options?: SubscriptionOptions<T>): Subscription<T | undefined>;
+/**
+ * An atomic signal. A signal where the getter and setter are combined into one function.
+ *
+ * @see {@link Atom}, {@link asig} (constructor)
+ */
+export type Asig<T> = Atom<Signal<T>>;
+/**
+ * Create an atomic signal. Short for `atom(createSignal(...))`.
+ * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atomic-signals-asig)
+ *
+ * @see {@link Asig} (output), {@link Atom}, {@link atom}
+ *
+ * @example
+ * ```ts
+ * const count = asig(0);
+ *
+ * count(10);
+ * console.log(count()); // 10
+ *
+ * count(x => x + 10);
+ * console.log(count()); // 20
+ * ```
+ */
+export declare function asig<T>(value: T, options?: SignalOptions<T>): Asig<T>;
+export declare function asig<T>(): Asig<T | undefined>;
+/**
+ * Create an atomic getter setter pair. Short for `atom(createPair(...))`.
+ * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atomic-pairs-apair)
+ *
+ * @see {@link Accessor} (input), {@link Update} (input), {@link PairOptions} (input), {@link Asig} (output)
+ *
+ * @example
+ * ```ts
+ * const count = asig(0);
+ * const double = apair(() => count() * 2, (x) => count(x / 2));
+ *
+ * count(10);
+ * console.log(count(), double()); // 10 20
+ *
+ * double(100);
+ * console.log(count(), double()); // 50 100
+ * ```
+ */
+export declare function apair<T>(getter: Accessor<T>, setter: Update<T>, options?: PairOptions): Asig<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-state-tools",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "A collection of Solid JS state utilities",
   "author": "Reed Syllas <reedsyllas@gmail.com>",
   "license": "ISC",
@@ -17,24 +17,28 @@
   ],
   "exports": {
     "import": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
+      "import": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
     }
   },
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
   "files": [
     "dist"
   ],
   "devDependencies": {
     "@types/node": "^24.10.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-solid": "^2.11.10"
   },
   "peerDependencies": {
     "solid-js": "^1.9.10"
   },
   "scripts": {
-    "build": "tsc"
+    "dev": "vite dev",
+    "build": "vite build"
   }
 }

package/dist/index.d.ts

@@ -1,126 +0,0 @@
-import { type Accessor, type Signal, type SignalOptions } from "solid-js";
-/**
- * @description
- * Any tuple of two functions where the first accepts no arguments and the second accepts any amount.
- *
- * Used as the source of an {@link Atom}.
- *
- * @see {@link Atom}, {@link atom}
- */
-export type SignalLike = readonly [() => any, (...args: any) => any];
-/**
- * @description
- * An {@link Atom} is a polymorphic function that calls one of two
- *  functions depending on the number of arguments it has.
- *
- * If called with zero arguments, the first function is called.
- * Otherwise, the second function is called with all arguments forwarded to it.
- *
- * @see {@link SignalLike}, {@link atom} (constructor)
- */
-export type Atom<T extends SignalLike = SignalLike> = T[0] & T[1];
-/**
- * @description
- * Combine a getter and setter function pair into one.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atoms-atom)
- *
- * 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.
- *
- * @see {@link SignalLike} (input), {@link Atom} (output)
- *
- * @example
- * ```
- * const count: Atom<Signal<T>> = atom(createSignal(0));
- *
- * // Read
- * count();
- *
- * // Write
- * count(100);
- * count(x => x + 1);
- * count(count() + 1);
- * ```
- */
-export declare function atom<const T extends SignalLike>(signal: T): Atom<T>;
-/**
- * @description
- * Similar to a signal setter, except it doesn't accept a mapping function nor return a result.
- *
- * @see {@link createPair} (for example usage)
- */
-export type Writer<T> = (value: T) => void;
-export interface PairOptions {
-    /**
-     * @default true
-     */
-    memoized: boolean;
-}
-/**
- * @description
- * Create a signal from a getter setter pair.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#pairs-createpair)
- *
- * **The getter is immediately invoked for memoization.**
- *
- * @see {@link Accessor} (input), {@link Writer} (input), {@link PairOptions} (input), {@link Signal} (output)
- *
- * @example
- * ```
- * const [ count, setCount ] = createSignal(0);
- * const [ double, setDouble ] = createPair(() => count() * 2, (x) => setCount(x / 2));
- *
- * setDouble(x => x + 2);
- * console.log(double(), count()); // 2 1
- * ```
- */
-export declare function createPair<T>(getter: Accessor<T>, setter: Writer<T>, options?: PairOptions): Signal<T>;
-/**
- * @description
- * An atomic signal. A signal where the getter and setter are combined into one function.
- *
- * @see {@link Atom}, {@link asig} (constructor)
- */
-export type Asig<T> = Atom<Signal<T>>;
-/**
- * @description
- * Create an atomic signal. Short for `atom(createSignal(...))`.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atomic-signals-asig)
- *
- * @see {@link Asig} (output), {@link Atom}, {@link atom}
- *
- * @example
- * ```
- * const count = asig(0);
- *
- * count(10);
- * console.log(count()); // 10
- *
- * count(x => x + 10);
- * console.log(count()); // 20
- * ```
- */
-export declare function asig<T>(value: T, options?: SignalOptions<T>): Asig<T>;
-export declare function asig<T>(): Asig<T | undefined>;
-/**
- * @description
- * Create an atomic getter setter pair. Short for `atom(createPair(...))`.
- * [See documentation.](https://github.com/ReedSyllas/solid-state-tools#atomic-pairs-apair)
- *
- * @see {@link Accessor} (input), {@link Writer} (input), {@link PairOptions} (input), {@link Asig} (output)
- *
- * @example
- * ```
- * const count = asig(0);
- * const double = apair(() => count() * 2, (x) => count(x / 2));
- *
- * count(10);
- * console.log(count(), double()); // 10 20
- *
- * double(100);
- * console.log(count(), double()); // 50 100
- * ```
- */
-export declare function apair<T>(getter: Accessor<T>, setter: Writer<T>, options?: PairOptions): Asig<T>;