@figliolia/galena 3.0.2 → 4.0.0

package/dist/State.d.cts

@@ -1,19 +1,20 @@
 import { NonFunction, Setter, Subscriber } from "./types.cjs";
 import { Middleware } from "./Middleware.cjs";
+import { API } from "./API.cjs";
 
 //#region src/State.d.ts
 /**
- * State
+ * ### State
  *
  * The unit of reactivity for Galena. `State`'s can act
  * as isolated instances or be part of your global app
  * state (via `Galena` instances).
  *
- * There are three ways to create state instances
+ * There are two ways to create state instances
  *
  * ```typescript
- * import { State, createState, useState, Profiler } from "@figliolia/galena";
- * // for island states that can be shared between react components
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ 
  * const myState = new State("<any value>", ...middleware);
  * // or
  * const myState = createState("<any value>", ...middleware);
@@ -22,23 +23,14 @@ import { Middleware } from "./Middleware.cjs";
  * myState.update(previousValue => "<new-value>");
  * myState.subscribe(nextValue => {});
  * myState.registerMiddleware(new Profiler());
- *
- * // Similarly if you wish to use your state inside a react component
- * const MyComponent = () => {
- *   const [state, setState] = useState(myState);
- *   // or
- *   const [state, setState] = useMyState("<any-value>", ...middlware);
- *
- *   return (
- *      // your jsx
- *   );
- * }
+ * myState.reset(); // reset back to it's original value
+ * // to get the current value at any point in time
+ * const currentValue = myState.getState();
  * ```
  */
-declare class State<T> {
+declare class State<T> extends API<T, NonFunction<T>> {
   readonly initialState: NonFunction<T>;
   private state;
-  readonly middleware: Middleware<T>[];
   private readonly Emitter;
   constructor(initialState: NonFunction<T>, ...middleware: Middleware<T>[]);
   /**
@@ -69,7 +61,7 @@ declare class State<T> {
    * Returns the current state. Designed for compatibility with
    * `useSyncExternalStore`
    */
-  readonly getSnapshot: () => NonFunction<T>;
+  readonly getState: () => NonFunction<T>;
   /**
    * Subscribe
    *
@@ -91,21 +83,28 @@ declare class State<T> {
   private invokeMiddleware;
 }
 /**
- * Create State
+ * ### createState
  *
- * Returns the unit of reactivity for Galena. `State`'s can act
+ * The unit of reactivity for Galena. `State`'s can act
  * as isolated instances or be part of your global app
- * state (via `Galena` instances);
+ * state (via `Galena` instances).
  *
- * ```typescript
- * import { createState, Profiler } from "@figliolia/galena";
+ * There are two ways to create state instances
  *
+ * ```typescript
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ 
+ * const myState = new State("<any value>", ...middleware);
+ * // or
  * const myState = createState("<any value>", ...middleware);
  *
  * myState.set("<new-value>");
  * myState.update(previousValue => "<new-value>");
  * myState.subscribe(nextValue => {});
  * myState.registerMiddleware(new Profiler());
+ * myState.reset(); // reset back to it's original value
+ * // to get the current value at any point in time
+ * const currentValue = myState.getState();
  * ```
  */
 declare function createState<T>(...args: ConstructorParameters<typeof State<T>>): State<T>;

package/dist/State.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"State.d.cts","names":[],"sources":["../src/State.ts"],"mappings":";;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;EAAA,SAKO,YAAA,EAAc,WAAA,CAAY,CAAA;EAAA,QAJpC,KAAA;EAAA,SACQ,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,iBACtB,OAAA;cAEC,YAAA,EAAc,WAAA,CAAY,CAAA,MACvC,UAAA,EAAY,UAAA,CAAW,CAAA;EADI;;;;;;EAAA,SAahB,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAAA;;;;;;;EAAA,SASH,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EAqBN;;;;;;EAAA,SARA,KAAA;EAgCT;;;;;;EAAA,SAxBS,WAAA,QAAW,WAAA,CAAA,CAAA;EAgDE;;;;;;EAAA,SAtCb,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EA0CpB;;AAyB1B;;;;;EArDS,kBAAA,CAAA,GAAsB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,QAI5C,YAAA;EAAA,QAaA,IAAA;EAAA,UAOE,UAAA,CAAW,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,WAAA,CAAY,CAAA;EAAA,QAIvD,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAyBM,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}
+{"version":3,"file":"State.d.cts","names":[],"sources":["../src/State.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,KAAA,YAAiB,GAAA,CAAI,CAAA,EAAG,WAAA,CAAY,CAAA;EAAA,SAI7B,YAAA,EAAc,WAAA,CAAY,CAAA;EAAA,QAHpC,KAAA;EAAA,iBACS,OAAA;cAEC,YAAA,EAAc,WAAA,CAAY,CAAA,MACvC,UAAA,EAAY,UAAA,CAAW,CAAA;EALG;;;;;;EAAA,SAiBf,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAba;;;;;;;EAAA,SAsBhB,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EArBjB;;;;;;EAAA,SAkCW,KAAA;EAbA;;;;;;EAAA,SAqBA,QAAA,QAAQ,WAAA,CAAA,CAAA;EAAA;;;;;;EAAA,SAUR,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EAcH;;;;;;;EAAlC,kBAAA,CAAA,GAAsB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,QAI5C,YAAA;EAAA,QAaA,IAAA;EAAA,UAOE,UAAA,CAAW,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,WAAA,CAAY,CAAA;EAAA,QAIvD,gBAAA;AAAA;;AAgCV;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}

package/dist/State.d.mts

@@ -1,19 +1,20 @@
 import { NonFunction, Setter, Subscriber } from "./types.mjs";
 import { Middleware } from "./Middleware.mjs";
+import { API } from "./API.mjs";
 
 //#region src/State.d.ts
 /**
- * State
+ * ### State
  *
  * The unit of reactivity for Galena. `State`'s can act
  * as isolated instances or be part of your global app
  * state (via `Galena` instances).
  *
- * There are three ways to create state instances
+ * There are two ways to create state instances
  *
  * ```typescript
- * import { State, createState, useState, Profiler } from "@figliolia/galena";
- * // for island states that can be shared between react components
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ 
  * const myState = new State("<any value>", ...middleware);
  * // or
  * const myState = createState("<any value>", ...middleware);
@@ -22,23 +23,14 @@ import { Middleware } from "./Middleware.mjs";
  * myState.update(previousValue => "<new-value>");
  * myState.subscribe(nextValue => {});
  * myState.registerMiddleware(new Profiler());
- *
- * // Similarly if you wish to use your state inside a react component
- * const MyComponent = () => {
- *   const [state, setState] = useState(myState);
- *   // or
- *   const [state, setState] = useMyState("<any-value>", ...middlware);
- *
- *   return (
- *      // your jsx
- *   );
- * }
+ * myState.reset(); // reset back to it's original value
+ * // to get the current value at any point in time
+ * const currentValue = myState.getState();
  * ```
  */
-declare class State<T> {
+declare class State<T> extends API<T, NonFunction<T>> {
   readonly initialState: NonFunction<T>;
   private state;
-  readonly middleware: Middleware<T>[];
   private readonly Emitter;
   constructor(initialState: NonFunction<T>, ...middleware: Middleware<T>[]);
   /**
@@ -69,7 +61,7 @@ declare class State<T> {
    * Returns the current state. Designed for compatibility with
    * `useSyncExternalStore`
    */
-  readonly getSnapshot: () => NonFunction<T>;
+  readonly getState: () => NonFunction<T>;
   /**
    * Subscribe
    *
@@ -91,21 +83,28 @@ declare class State<T> {
   private invokeMiddleware;
 }
 /**
- * Create State
+ * ### createState
  *
- * Returns the unit of reactivity for Galena. `State`'s can act
+ * The unit of reactivity for Galena. `State`'s can act
  * as isolated instances or be part of your global app
- * state (via `Galena` instances);
+ * state (via `Galena` instances).
  *
- * ```typescript
- * import { createState, Profiler } from "@figliolia/galena";
+ * There are two ways to create state instances
  *
+ * ```typescript
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ 
+ * const myState = new State("<any value>", ...middleware);
+ * // or
  * const myState = createState("<any value>", ...middleware);
  *
  * myState.set("<new-value>");
  * myState.update(previousValue => "<new-value>");
  * myState.subscribe(nextValue => {});
  * myState.registerMiddleware(new Profiler());
+ * myState.reset(); // reset back to it's original value
+ * // to get the current value at any point in time
+ * const currentValue = myState.getState();
  * ```
  */
 declare function createState<T>(...args: ConstructorParameters<typeof State<T>>): State<T>;

package/dist/State.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"State.d.mts","names":[],"sources":["../src/State.ts"],"mappings":";;;;;;AAqCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,KAAA;EAAA,SAKO,YAAA,EAAc,WAAA,CAAY,CAAA;EAAA,QAJpC,KAAA;EAAA,SACQ,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,iBACtB,OAAA;cAEC,YAAA,EAAc,WAAA,CAAY,CAAA,MACvC,UAAA,EAAY,UAAA,CAAW,CAAA;EADI;;;;;;EAAA,SAahB,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAAA;;;;;;;EAAA,SASH,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EAqBN;;;;;;EAAA,SARA,KAAA;EAgCT;;;;;;EAAA,SAxBS,WAAA,QAAW,WAAA,CAAA,CAAA;EAgDE;;;;;;EAAA,SAtCb,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EA0CpB;;AAyB1B;;;;;EArDS,kBAAA,CAAA,GAAsB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,QAI5C,YAAA;EAAA,QAaA,IAAA;EAAA,UAOE,UAAA,CAAW,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,WAAA,CAAY,CAAA;EAAA,QAIvD,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAyBM,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}
+{"version":3,"file":"State.d.mts","names":[],"sources":["../src/State.ts"],"mappings":";;;;;;;AA8BA;;;;;;;;;;;;;;;;;;;;;;;cAAa,KAAA,YAAiB,GAAA,CAAI,CAAA,EAAG,WAAA,CAAY,CAAA;EAAA,SAI7B,YAAA,EAAc,WAAA,CAAY,CAAA;EAAA,QAHpC,KAAA;EAAA,iBACS,OAAA;cAEC,YAAA,EAAc,WAAA,CAAY,CAAA,MACvC,UAAA,EAAY,UAAA,CAAW,CAAA;EALG;;;;;;EAAA,SAiBf,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAba;;;;;;;EAAA,SAsBhB,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EArBjB;;;;;;EAAA,SAkCW,KAAA;EAbA;;;;;;EAAA,SAqBA,QAAA,QAAQ,WAAA,CAAA,CAAA;EAAA;;;;;;EAAA,SAUR,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EAcH;;;;;;;EAAlC,kBAAA,CAAA,GAAsB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,QAI5C,YAAA;EAAA,QAaA,IAAA;EAAA,UAOE,UAAA,CAAW,MAAA,EAAQ,MAAA,CAAO,CAAA,IAAK,MAAA,IAAU,WAAA,CAAY,CAAA;EAAA,QAIvD,gBAAA;AAAA;;AAgCV;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}

package/dist/State.mjs

@@ -1,17 +1,18 @@
+import { API } from "./API.mjs";
 import { EventEmitter } from "@figliolia/event-emitter";
 //#region src/State.ts
 /**
-* State
+* ### State
 *
 * The unit of reactivity for Galena. `State`'s can act
 * as isolated instances or be part of your global app
 * state (via `Galena` instances).
 *
-* There are three ways to create state instances
+* There are two ways to create state instances
 *
 * ```typescript
-* import { State, createState, useState, Profiler } from "@figliolia/galena";
-* // for island states that can be shared between react components
+* import { State, createState, Profiler } from "@figliolia/galena";
+
 * const myState = new State("<any value>", ...middleware);
 * // or
 * const myState = createState("<any value>", ...middleware);
@@ -20,27 +21,18 @@ import { EventEmitter } from "@figliolia/event-emitter";
 * myState.update(previousValue => "<new-value>");
 * myState.subscribe(nextValue => {});
 * myState.registerMiddleware(new Profiler());
-*
-* // Similarly if you wish to use your state inside a react component
-* const MyComponent = () => {
-*   const [state, setState] = useState(myState);
-*   // or
-*   const [state, setState] = useMyState("<any-value>", ...middlware);
-*
-*   return (
-*      // your jsx
-*   );
-* }
+* myState.reset(); // reset back to it's original value
+* // to get the current value at any point in time
+* const currentValue = myState.getState();
 * ```
 */
-var State = class {
+var State = class extends API {
 	state;
-	middleware = [];
 	Emitter = new EventEmitter();
 	constructor(initialState, ...middleware) {
+		super(...middleware);
 		this.initialState = initialState;
 		this.state = initialState;
-		this.registerMiddleware(...middleware);
 	}
 	/**
 	* Set
@@ -73,7 +65,7 @@ var State = class {
 	* Returns the current state. Designed for compatibility with
 	* `useSyncExternalStore`
 	*/
-	getSnapshot = () => {
+	getState = () => {
 		return this.state;
 	};
 	/**
@@ -122,21 +114,28 @@ var State = class {
 	}
 };
 /**
-* Create State
+* ### createState
 *
-* Returns the unit of reactivity for Galena. `State`'s can act
+* The unit of reactivity for Galena. `State`'s can act
 * as isolated instances or be part of your global app
-* state (via `Galena` instances);
+* state (via `Galena` instances).
 *
-* ```typescript
-* import { createState, Profiler } from "@figliolia/galena";
+* There are two ways to create state instances
 *
+* ```typescript
+* import { State, createState, Profiler } from "@figliolia/galena";
+
+* const myState = new State("<any value>", ...middleware);
+* // or
 * const myState = createState("<any value>", ...middleware);
 *
 * myState.set("<new-value>");
 * myState.update(previousValue => "<new-value>");
 * myState.subscribe(nextValue => {});
 * myState.registerMiddleware(new Profiler());
+* myState.reset(); // reset back to it's original value
+* // to get the current value at any point in time
+* const currentValue = myState.getState();
 * ```
 */
 function createState(...args) {

package/dist/State.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"State.mjs","names":[],"sources":["../src/State.ts"],"sourcesContent":["import { EventEmitter } from \"@figliolia/event-emitter\";\nimport type { Middleware } from \"./Middleware\";\nimport type { NonFunction, Setter, Subscriber } from \"./types\";\n\n/**\n * State\n *\n * The unit of reactivity for Galena. `State`'s can act\n * as isolated instances or be part of your global app\n * state (via `Galena` instances).\n *\n * There are three ways to create state instances\n *\n * ```typescript\n * import { State, createState, useState, Profiler } from \"@figliolia/galena\";\n * // for island states that can be shared between react components\n * const myState = new State(\"<any value>\", ...middleware);\n * // or\n * const myState = createState(\"<any value>\", ...middleware);\n *\n * myState.set(\"<new-value>\");\n * myState.update(previousValue => \"<new-value>\");\n * myState.subscribe(nextValue => {});\n * myState.registerMiddleware(new Profiler());\n *\n * // Similarly if you wish to use your state inside a react component\n * const MyComponent = () => {\n *   const [state, setState] = useState(myState);\n *   // or\n *   const [state, setState] = useMyState(\"<any-value>\", ...middlware);\n *\n *   return (\n *      // your jsx\n *   );\n * }\n * ```\n */\nexport class State<T> {\n  private state: NonFunction<T>;\n  public readonly middleware: Middleware<T>[] = [];\n  private readonly Emitter = new EventEmitter<{ change: NonFunction<T> }>();\n  constructor(\n    public readonly initialState: NonFunction<T>,\n    ...middleware: Middleware<T>[]\n  ) {\n    this.state = initialState;\n    this.registerMiddleware(...middleware);\n  }\n\n  /**\n   * Set\n   *\n   * Updates the current value of state notifying\n   * all interested parties\n   */\n  public readonly set = this.withEmission((state: NonFunction<T>) => state);\n\n  /**\n   * Update\n   *\n   * Updates the current value of state using a setter function\n   * receiving the previous state as a parameter. Notifies all\n   * interested parties\n   */\n  public readonly update = this.withEmission((setter: Setter<T>) => {\n    if (this.diffSetter(setter)) {\n      return setter;\n    }\n    return setter(this.state);\n  });\n\n  /**\n   * Reset\n   *\n   * Resets the current state back to the state which the instance\n   * was initialized with. Notifies all interested parties\n   */\n  public readonly reset = this.withEmission(() => this.initialState);\n\n  /**\n   * Get Snapshot\n   *\n   * Returns the current state. Designed for compatibility with\n   * `useSyncExternalStore`\n   */\n  public readonly getSnapshot = () => {\n    return this.state;\n  };\n\n  /**\n   * Subscribe\n   *\n   * Registers a callback to be executed each time state\n   * changes. Returns an `unsubscribe` function\n   */\n  public readonly subscribe = (fn: Subscriber<T>) => {\n    const ID = this.Emitter.on(\"change\", fn);\n    return () => {\n      this.Emitter.off(\"change\", ID);\n    };\n  };\n\n  /**\n   * Register Middleware\n   *\n   * Registers any number of `Middleware` instances on the\n   * current instance of `State`. Your middleware will begin\n   * executing at the next state transition\n   */\n  public registerMiddleware(...middleware: Middleware<T>[]) {\n    this.middleware.push(...middleware);\n  }\n\n  private withEmission<\n    F extends (...args: any[]) => NonFunction<T> | Promise<NonFunction<T>>,\n  >(fn: F) {\n    return (...args: Parameters<F>) => {\n      const result = fn(...args);\n      if (result instanceof Promise) {\n        void result.then(resolved => this.emit(resolved));\n        return;\n      }\n      return this.emit(result);\n    };\n  }\n\n  private emit(nextState: NonFunction<T>) {\n    this.invokeMiddleware(\"onBeforeUpdate\");\n    this.state = nextState;\n    this.Emitter.emit(\"change\", this.state);\n    this.invokeMiddleware(\"onUpdate\");\n  }\n\n  protected diffSetter(setter: Setter<T>): setter is NonFunction<T> {\n    return typeof setter !== \"function\";\n  }\n\n  private invokeMiddleware<K extends keyof Middleware<T>>(fn: K) {\n    for (const middleware of this.middleware) {\n      middleware[fn](this);\n    }\n  }\n}\n\n/**\n * Create State\n *\n * Returns the unit of reactivity for Galena. `State`'s can act\n * as isolated instances or be part of your global app\n * state (via `Galena` instances);\n *\n * ```typescript\n * import { createState, Profiler } from \"@figliolia/galena\";\n *\n * const myState = createState(\"<any value>\", ...middleware);\n *\n * myState.set(\"<new-value>\");\n * myState.update(previousValue => \"<new-value>\");\n * myState.subscribe(nextValue => {});\n * myState.registerMiddleware(new Profiler());\n * ```\n */\nexport function createState<T>(\n  ...args: ConstructorParameters<typeof State<T>>\n) {\n  return new State<T>(...args);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,QAAb,MAAsB;CACpB;CACA,aAA8C,EAAE;CAChD,UAA2B,IAAI,cAA0C;CACzE,YACE,cACA,GAAG,YACH;AAFgB,OAAA,eAAA;AAGhB,OAAK,QAAQ;AACb,OAAK,mBAAmB,GAAG,WAAW;;;;;;;;CASxC,MAAsB,KAAK,cAAc,UAA0B,MAAM;;;;;;;;CASzE,SAAyB,KAAK,cAAc,WAAsB;AAChE,MAAI,KAAK,WAAW,OAAO,CACzB,QAAO;AAET,SAAO,OAAO,KAAK,MAAM;GACzB;;;;;;;CAQF,QAAwB,KAAK,mBAAmB,KAAK,aAAa;;;;;;;CAQlE,oBAAoC;AAClC,SAAO,KAAK;;;;;;;;CASd,aAA6B,OAAsB;EACjD,MAAM,KAAK,KAAK,QAAQ,GAAG,UAAU,GAAG;AACxC,eAAa;AACX,QAAK,QAAQ,IAAI,UAAU,GAAG;;;;;;;;;;CAWlC,mBAA0B,GAAG,YAA6B;AACxD,OAAK,WAAW,KAAK,GAAG,WAAW;;CAGrC,aAEE,IAAO;AACP,UAAQ,GAAG,SAAwB;GACjC,MAAM,SAAS,GAAG,GAAG,KAAK;AAC1B,OAAI,kBAAkB,SAAS;AACxB,WAAO,MAAK,aAAY,KAAK,KAAK,SAAS,CAAC;AACjD;;AAEF,UAAO,KAAK,KAAK,OAAO;;;CAI5B,KAAa,WAA2B;AACtC,OAAK,iBAAiB,iBAAiB;AACvC,OAAK,QAAQ;AACb,OAAK,QAAQ,KAAK,UAAU,KAAK,MAAM;AACvC,OAAK,iBAAiB,WAAW;;CAGnC,WAAqB,QAA6C;AAChE,SAAO,OAAO,WAAW;;CAG3B,iBAAwD,IAAO;AAC7D,OAAK,MAAM,cAAc,KAAK,WAC5B,YAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;AAuB1B,SAAgB,YACd,GAAG,MACH;AACA,QAAO,IAAI,MAAS,GAAG,KAAK"}
+{"version":3,"file":"State.mjs","names":[],"sources":["../src/State.ts"],"sourcesContent":["import { EventEmitter } from \"@figliolia/event-emitter\";\nimport { API } from \"./API\";\nimport type { Middleware } from \"./Middleware\";\nimport type { NonFunction, Setter, Subscriber } from \"./types\";\n\n/**\n * ### State\n *\n * The unit of reactivity for Galena. `State`'s can act\n * as isolated instances or be part of your global app\n * state (via `Galena` instances).\n *\n * There are two ways to create state instances\n *\n * ```typescript\n * import { State, createState, Profiler } from \"@figliolia/galena\";\n \n * const myState = new State(\"<any value>\", ...middleware);\n * // or\n * const myState = createState(\"<any value>\", ...middleware);\n *\n * myState.set(\"<new-value>\");\n * myState.update(previousValue => \"<new-value>\");\n * myState.subscribe(nextValue => {});\n * myState.registerMiddleware(new Profiler());\n * myState.reset(); // reset back to it's original value\n * // to get the current value at any point in time\n * const currentValue = myState.getState();\n * ```\n */\nexport class State<T> extends API<T, NonFunction<T>> {\n  private state: NonFunction<T>;\n  private readonly Emitter = new EventEmitter<{ change: NonFunction<T> }>();\n  constructor(\n    public readonly initialState: NonFunction<T>,\n    ...middleware: Middleware<T>[]\n  ) {\n    super(...middleware);\n    this.state = initialState;\n  }\n\n  /**\n   * Set\n   *\n   * Updates the current value of state notifying\n   * all interested parties\n   */\n  public readonly set = this.withEmission((state: NonFunction<T>) => state);\n\n  /**\n   * Update\n   *\n   * Updates the current value of state using a setter function\n   * receiving the previous state as a parameter. Notifies all\n   * interested parties\n   */\n  public readonly update = this.withEmission((setter: Setter<T>) => {\n    if (this.diffSetter(setter)) {\n      return setter;\n    }\n    return setter(this.state);\n  });\n\n  /**\n   * Reset\n   *\n   * Resets the current state back to the state which the instance\n   * was initialized with. Notifies all interested parties\n   */\n  public readonly reset = this.withEmission(() => this.initialState);\n\n  /**\n   * Get Snapshot\n   *\n   * Returns the current state. Designed for compatibility with\n   * `useSyncExternalStore`\n   */\n  public readonly getState = () => {\n    return this.state;\n  };\n\n  /**\n   * Subscribe\n   *\n   * Registers a callback to be executed each time state\n   * changes. Returns an `unsubscribe` function\n   */\n  public readonly subscribe = (fn: Subscriber<T>) => {\n    const ID = this.Emitter.on(\"change\", fn);\n    return () => {\n      this.Emitter.off(\"change\", ID);\n    };\n  };\n\n  /**\n   * Register Middleware\n   *\n   * Registers any number of `Middleware` instances on the\n   * current instance of `State`. Your middleware will begin\n   * executing at the next state transition\n   */\n  public registerMiddleware(...middleware: Middleware<T>[]) {\n    this.middleware.push(...middleware);\n  }\n\n  private withEmission<\n    F extends (...args: any[]) => NonFunction<T> | Promise<NonFunction<T>>,\n  >(fn: F) {\n    return (...args: Parameters<F>) => {\n      const result = fn(...args);\n      if (result instanceof Promise) {\n        void result.then(resolved => this.emit(resolved));\n        return;\n      }\n      return this.emit(result);\n    };\n  }\n\n  private emit(nextState: NonFunction<T>) {\n    this.invokeMiddleware(\"onBeforeUpdate\");\n    this.state = nextState;\n    this.Emitter.emit(\"change\", this.state);\n    this.invokeMiddleware(\"onUpdate\");\n  }\n\n  protected diffSetter(setter: Setter<T>): setter is NonFunction<T> {\n    return typeof setter !== \"function\";\n  }\n\n  private invokeMiddleware<K extends keyof Middleware<T>>(fn: K) {\n    for (const middleware of this.middleware) {\n      middleware[fn](this);\n    }\n  }\n}\n\n/**\n * ### createState\n *\n * The unit of reactivity for Galena. `State`'s can act\n * as isolated instances or be part of your global app\n * state (via `Galena` instances).\n *\n * There are two ways to create state instances\n *\n * ```typescript\n * import { State, createState, Profiler } from \"@figliolia/galena\";\n \n * const myState = new State(\"<any value>\", ...middleware);\n * // or\n * const myState = createState(\"<any value>\", ...middleware);\n *\n * myState.set(\"<new-value>\");\n * myState.update(previousValue => \"<new-value>\");\n * myState.subscribe(nextValue => {});\n * myState.registerMiddleware(new Profiler());\n * myState.reset(); // reset back to it's original value\n * // to get the current value at any point in time\n * const currentValue = myState.getState();\n * ```\n */\nexport function createState<T>(\n  ...args: ConstructorParameters<typeof State<T>>\n) {\n  return new State<T>(...args);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,QAAb,cAA8B,IAAuB;CACnD;CACA,UAA2B,IAAI,cAA0C;CACzE,YACE,cACA,GAAG,YACH;AACA,QAAM,GAAG,WAAW;AAHJ,OAAA,eAAA;AAIhB,OAAK,QAAQ;;;;;;;;CASf,MAAsB,KAAK,cAAc,UAA0B,MAAM;;;;;;;;CASzE,SAAyB,KAAK,cAAc,WAAsB;AAChE,MAAI,KAAK,WAAW,OAAO,CACzB,QAAO;AAET,SAAO,OAAO,KAAK,MAAM;GACzB;;;;;;;CAQF,QAAwB,KAAK,mBAAmB,KAAK,aAAa;;;;;;;CAQlE,iBAAiC;AAC/B,SAAO,KAAK;;;;;;;;CASd,aAA6B,OAAsB;EACjD,MAAM,KAAK,KAAK,QAAQ,GAAG,UAAU,GAAG;AACxC,eAAa;AACX,QAAK,QAAQ,IAAI,UAAU,GAAG;;;;;;;;;;CAWlC,mBAA0B,GAAG,YAA6B;AACxD,OAAK,WAAW,KAAK,GAAG,WAAW;;CAGrC,aAEE,IAAO;AACP,UAAQ,GAAG,SAAwB;GACjC,MAAM,SAAS,GAAG,GAAG,KAAK;AAC1B,OAAI,kBAAkB,SAAS;AACxB,WAAO,MAAK,aAAY,KAAK,KAAK,SAAS,CAAC;AACjD;;AAEF,UAAO,KAAK,KAAK,OAAO;;;CAI5B,KAAa,WAA2B;AACtC,OAAK,iBAAiB,iBAAiB;AACvC,OAAK,QAAQ;AACb,OAAK,QAAQ,KAAK,UAAU,KAAK,MAAM;AACvC,OAAK,iBAAiB,WAAW;;CAGnC,WAAqB,QAA6C;AAChE,SAAO,OAAO,WAAW;;CAG3B,iBAAwD,IAAO;AAC7D,OAAK,MAAM,cAAc,KAAK,WAC5B,YAAW,IAAI,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8B1B,SAAgB,YACd,GAAG,MACH;AACA,QAAO,IAAI,MAAS,GAAG,KAAK"}

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber } from "./types.cjs";
+import { AppSubscriber, GalenaSnapshot, GalenaState, NonFunction, PartialSupport, Setter, StateType, StateTypes, Subscriber } from "./types.cjs";
 import { State, createState } from "./State.cjs";
 import { Middleware } from "./Middleware.cjs";
 import { Galena, createGalena } from "./Galena.cjs";
 import { Logger } from "./Logger.cjs";
 import { Profiler } from "./Profiler.cjs";
-export { AppSubscriber, Galena, GalenaSnapshot, Logger, Middleware, NonFunction, PartialSupport, Profiler, Setter, State, StateTypes, Subscriber, createGalena, createState };
+export { AppSubscriber, Galena, GalenaSnapshot, GalenaState, Logger, Middleware, NonFunction, PartialSupport, Profiler, Setter, State, StateType, StateTypes, Subscriber, createGalena, createState };

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber } from "./types.mjs";
+import { AppSubscriber, GalenaSnapshot, GalenaState, NonFunction, PartialSupport, Setter, StateType, StateTypes, Subscriber } from "./types.mjs";
 import { State, createState } from "./State.mjs";
 import { Middleware } from "./Middleware.mjs";
 import { Galena, createGalena } from "./Galena.mjs";
 import { Logger } from "./Logger.mjs";
 import { Profiler } from "./Profiler.mjs";
-export { AppSubscriber, Galena, GalenaSnapshot, Logger, Middleware, NonFunction, PartialSupport, Profiler, Setter, State, StateTypes, Subscriber, createGalena, createState };
+export { AppSubscriber, Galena, GalenaSnapshot, GalenaState, Logger, Middleware, NonFunction, PartialSupport, Profiler, Setter, State, StateType, StateTypes, Subscriber, createGalena, createState };

package/dist/types.d.cts

@@ -10,7 +10,9 @@ interface GalenaSnapshot<T extends Record<string, State<any>>, K extends Extract
   state: T;
 }
 type AppSubscriber<T extends Record<string, State<any>>, K extends Extract<keyof T, string> = Extract<keyof T, string>> = ((payload: GalenaSnapshot<T, K>) => void) | (() => void);
-type StateTypes<T extends Record<string, State<any>>> = ReturnType<T[keyof T]["getSnapshot"]>;
+type StateTypes<T extends Record<string, State<any>>> = ReturnType<StateType<T[keyof T]>>;
+type StateType<T extends State<any>> = ReturnType<T["getState"]>;
+type GalenaState<T extends Record<string, State<any>>> = { [K in keyof T]: StateType<T[K]> };
 //#endregion
-export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+export { AppSubscriber, GalenaSnapshot, GalenaState, NonFunction, PartialSupport, Setter, StateType, StateTypes, Subscriber };
 //# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAEY,WAAA,MAAiB,CAAA,cAAc,IAAA,2BAA8B,CAAA;AAAA,KAE7D,cAAA,MAAoB,CAAA,SAAU,MAAA,gBAAsB,OAAA,CAAQ,CAAA,IAAK,CAAA;AAAA,KAEjE,MAAA,MACR,WAAA,CAAY,CAAA,MACV,SAAA,EAAW,WAAA,CAAY,CAAA,MAAO,WAAA,CAAY,CAAA,IAAK,OAAA,CAAQ,WAAA,CAAY,CAAA;AAAA,KAE7D,UAAA,QAAkB,KAAA,EAAO,WAAA,CAAY,CAAA;AAAA,UAEhC,cAAA,WACL,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA;EAEnD,OAAA,EAAS,CAAA,CAAE,CAAA;EACX,KAAA,EAAO,CAAA;AAAA;AAAA,KAGG,aAAA,WACA,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA,eAC/C,OAAA,EAAS,cAAA,CAAe,CAAA,EAAG,CAAA;AAAA,KAErB,UAAA,WAAqB,MAAA,SAAe,KAAA,UAAe,UAAA,CAC7D,CAAA,OAAQ,CAAA"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAEY,WAAA,MAAiB,CAAA,cAAc,IAAA,2BAA8B,CAAA;AAAA,KAE7D,cAAA,MAAoB,CAAA,SAAU,MAAA,gBAAsB,OAAA,CAAQ,CAAA,IAAK,CAAA;AAAA,KAEjE,MAAA,MACR,WAAA,CAAY,CAAA,MACV,SAAA,EAAW,WAAA,CAAY,CAAA,MAAO,WAAA,CAAY,CAAA,IAAK,OAAA,CAAQ,WAAA,CAAY,CAAA;AAAA,KAE7D,UAAA,QAAkB,KAAA,EAAO,WAAA,CAAY,CAAA;AAAA,UAEhC,cAAA,WACL,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA;EAEnD,OAAA,EAAS,CAAA,CAAE,CAAA;EACX,KAAA,EAAO,CAAA;AAAA;AAAA,KAGG,aAAA,WACA,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA,eAC/C,OAAA,EAAS,cAAA,CAAe,CAAA,EAAG,CAAA;AAAA,KAErB,UAAA,WAAqB,MAAA,SAAe,KAAA,UAAe,UAAA,CAC7D,SAAA,CAAU,CAAA,OAAQ,CAAA;AAAA,KAGR,SAAA,WAAoB,KAAA,SAAc,UAAA,CAAW,CAAA;AAAA,KAE7C,WAAA,WAAsB,MAAA,SAAe,KAAA,wBACnC,CAAA,GAAI,SAAA,CAAU,CAAA,CAAE,CAAA"}

package/dist/types.d.mts

@@ -10,7 +10,9 @@ interface GalenaSnapshot<T extends Record<string, State<any>>, K extends Extract
   state: T;
 }
 type AppSubscriber<T extends Record<string, State<any>>, K extends Extract<keyof T, string> = Extract<keyof T, string>> = ((payload: GalenaSnapshot<T, K>) => void) | (() => void);
-type StateTypes<T extends Record<string, State<any>>> = ReturnType<T[keyof T]["getSnapshot"]>;
+type StateTypes<T extends Record<string, State<any>>> = ReturnType<StateType<T[keyof T]>>;
+type StateType<T extends State<any>> = ReturnType<T["getState"]>;
+type GalenaState<T extends Record<string, State<any>>> = { [K in keyof T]: StateType<T[K]> };
 //#endregion
-export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+export { AppSubscriber, GalenaSnapshot, GalenaState, NonFunction, PartialSupport, Setter, StateType, StateTypes, Subscriber };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAEY,WAAA,MAAiB,CAAA,cAAc,IAAA,2BAA8B,CAAA;AAAA,KAE7D,cAAA,MAAoB,CAAA,SAAU,MAAA,gBAAsB,OAAA,CAAQ,CAAA,IAAK,CAAA;AAAA,KAEjE,MAAA,MACR,WAAA,CAAY,CAAA,MACV,SAAA,EAAW,WAAA,CAAY,CAAA,MAAO,WAAA,CAAY,CAAA,IAAK,OAAA,CAAQ,WAAA,CAAY,CAAA;AAAA,KAE7D,UAAA,QAAkB,KAAA,EAAO,WAAA,CAAY,CAAA;AAAA,UAEhC,cAAA,WACL,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA;EAEnD,OAAA,EAAS,CAAA,CAAE,CAAA;EACX,KAAA,EAAO,CAAA;AAAA;AAAA,KAGG,aAAA,WACA,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA,eAC/C,OAAA,EAAS,cAAA,CAAe,CAAA,EAAG,CAAA;AAAA,KAErB,UAAA,WAAqB,MAAA,SAAe,KAAA,UAAe,UAAA,CAC7D,CAAA,OAAQ,CAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";;;KAEY,WAAA,MAAiB,CAAA,cAAc,IAAA,2BAA8B,CAAA;AAAA,KAE7D,cAAA,MAAoB,CAAA,SAAU,MAAA,gBAAsB,OAAA,CAAQ,CAAA,IAAK,CAAA;AAAA,KAEjE,MAAA,MACR,WAAA,CAAY,CAAA,MACV,SAAA,EAAW,WAAA,CAAY,CAAA,MAAO,WAAA,CAAY,CAAA,IAAK,OAAA,CAAQ,WAAA,CAAY,CAAA;AAAA,KAE7D,UAAA,QAAkB,KAAA,EAAO,WAAA,CAAY,CAAA;AAAA,UAEhC,cAAA,WACL,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA;EAEnD,OAAA,EAAS,CAAA,CAAE,CAAA;EACX,KAAA,EAAO,CAAA;AAAA;AAAA,KAGG,aAAA,WACA,MAAA,SAAe,KAAA,kBACf,OAAA,OAAc,CAAA,YAAa,OAAA,OAAc,CAAA,eAC/C,OAAA,EAAS,cAAA,CAAe,CAAA,EAAG,CAAA;AAAA,KAErB,UAAA,WAAqB,MAAA,SAAe,KAAA,UAAe,UAAA,CAC7D,SAAA,CAAU,CAAA,OAAQ,CAAA;AAAA,KAGR,SAAA,WAAoB,KAAA,SAAc,UAAA,CAAW,CAAA;AAAA,KAE7C,WAAA,WAAsB,MAAA,SAAe,KAAA,wBACnC,CAAA,GAAI,SAAA,CAAU,CAAA,CAAE,CAAA"}

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "@figliolia/galena",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "description": "A performant state management library supporting middleware and a rich developer API",
+  "keywords": [
+    "flux",
+    "react",
+    "state",
+    "state management"
+  ],
   "homepage": "https://github.com/alexfigliolia/galena#readme",
   "license": "MIT",
   "author": "Alex Figliolia",
@@ -48,11 +54,5 @@
   },
   "peerDependencies": {
     "@figliolia/event-emitter": ">=1.2.0"
-  },
-  "keywords": [
-    "state",
-    "state management",
-    "flux",
-    "react"
-  ]
+  }
 }

package/src/API.ts

@@ -0,0 +1,12 @@
+import type { Middleware } from "./Middleware";
+
+export abstract class API<T, E, M = T> {
+  public readonly middleware: Middleware<M>[] = [];
+  constructor(...middleware: Middleware<M>[]) {
+    this.registerMiddleware(...middleware);
+  }
+
+  public abstract getState(): T;
+  public abstract subscribe(subscriber: (payload: E) => void): () => void;
+  public abstract registerMiddleware(...middlewares: Middleware<M>[]): void;
+}

package/src/Galena.ts

@@ -1,52 +1,117 @@
 import { EventEmitter } from "@figliolia/event-emitter";
+import { API } from "./API";
 import type { Middleware } from "./Middleware";
 import type { State } from "./State";
-import type { AppSubscriber, GalenaSnapshot, StateTypes } from "./types";
+import type {
+  AppSubscriber,
+  GalenaSnapshot,
+  GalenaState,
+  Setter,
+  StateType,
+  StateTypes,
+} from "./types";
 
 /**
- * Galena
+ * ### Galena
  *
- * Galena is designed to house one or more units of `State`
+ * Galena instances are designed to house one or more units of `State`
  * and exist as a pseudo global application state.
  *
  * By design, each of its `State` units have isolated reactivity
  * that prevents entire state trees from updating when a single
  * unit changes.
  *
- * This is dissimilar to redux-like models where downstream reconciliations
- * will propagate everwhere a given store is read from. In galena, downstream
- * reconciliations occur only for consumers of the slice of state that
- * changed - making it safer to use with more frequent state changes.
- *
  * ```typescript
  * import { Galena } from "@figliolia/galena";
  *
  * const AppState = new Galena({
+ *   user: new State("<user-stuff>"),
+ *   business: new State("<business-logic-stuff>")
  *   // your reactive instances
  * }, ...middleware);
  *
  * // to retreive and work with an individual unit
- * const myUnit = AppState.get("<key>"); // Returns State<T>
+ * const userState = AppState.get("user"); // Returns State<T>
  *
  * // to run a callback anytime a unit of state changes
- * const unsubscribe = AppState.subscribe(({ updated }) => {
+ * const listener = AppState.subscribe(({ state, updated }) => {
  *   // do something with the `State` instance that updated
+ *   // the entirety of your state
  * });
+ *
+ * // get the current application state
+ * const currentState = AppState.getState();
+ *
+ * // operate on an instance of state
+ * AppState.update("user", userState => ({
+ *   ...userState,
+ *   // your updates
+ * }));
  * ```
  */
-export class Galena<T extends Record<string, State<any>>> {
+export class Galena<T extends Record<string, State<any>>> extends API<
+  GalenaState<T>,
+  GalenaSnapshot<T>,
+  StateTypes<T>
+> {
   private Emitter = new EventEmitter<{ change: GalenaSnapshot<T> }>();
   constructor(
     public readonly state: T,
     ...middleware: Middleware<StateTypes<T>>[]
   ) {
-    this.registerMiddleware(...middleware);
+    super(...middleware);
   }
 
+  public getState() {
+    const result = {} as GalenaState<T>;
+    for (const key in this.state) {
+      const state = key as keyof T;
+      result[state] = this.state[key].getState();
+    }
+    return result;
+  }
+
+  /**
+   * Get
+   *
+   * Returns a connected State instance by key
+   */
   public get<K extends Extract<keyof T, string>>(key: K) {
     return this.state[key];
   }
 
+  /**
+   * Set
+   *
+   * Sets a connected State instance's state by key
+   */
+  public set<K extends Extract<keyof T, string>>(
+    key: K,
+    value: StateType<T[K]>,
+  ) {
+    return this.get(key).set(value);
+  }
+
+  /**
+   * Update
+   *
+   * Invokes a connected State instance's update method key
+   */
+  public update<K extends Extract<keyof T, string>>(
+    key: K,
+    updater: Setter<StateType<T[K]>>,
+  ) {
+    return this.get(key).update(updater);
+  }
+
+  /**
+   * Subscribe
+   *
+   * Listen for changes on your Galena instnace. Your provided
+   * callback will be invoked each time an attached state instance
+   * changes. To your callback will be provided the `updated` state
+   * instance, along with the entire `state` tree
+   */
   public subscribe = (subscriber: AppSubscriber<T>) => {
     const ID = this.Emitter.on("change", subscriber);
     const unsubscribers: (() => void)[] = [];
@@ -69,6 +134,12 @@ export class Galena<T extends Record<string, State<any>>> {
     };
   };
 
+  /**
+   * Register Middleware
+   *
+   * Adds middleware instances to each of the connected
+   * `State` instances
+   */
   public registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]) {
     for (const key in this.state) {
       this.state[key]?.registerMiddleware?.(...middlewares);
@@ -83,34 +154,41 @@ export class Galena<T extends Record<string, State<any>>> {
 }
 
 /**
- * Create Galena
+ * ### createGalena
  *
- * Galena is designed to house one or more units of `State`
+ * Galena instances are designed to house one or more units of `State`
  * and exist as a pseudo global application state.
  *
  * By design, each of its `State` units have isolated reactivity
  * that prevents entire state trees from updating when a single
  * unit changes.
  *
- * This is dissimilar to redux-like models where downstream reconciliations
- * will propagate everwhere a given store is read from. In galena, downstream
- * reconciliations occur only for consumers of the slice of state that
- * changed - making it safer to use with more frequent state changes.
- *
  * ```typescript
- * import { createGalena } from "@figliolia/galena";
+ * import { Galena } from "@figliolia/galena";
  *
- * const AppState = createGalena({
+ * const AppState = new Galena({
+ *   user: new State("<user-stuff>"),
+ *   business: new State("<business-logic-stuff>")
  *   // your reactive instances
  * }, ...middleware);
  *
  * // to retreive and work with an individual unit
- * const myUnit = AppState.get("<key>"); // Returns State<T>
+ * const userState = AppState.get("user"); // Returns State<T>
  *
  * // to run a callback anytime a unit of state changes
- * const unsubscribe = AppState.subscribe(({ updated }) => {
+ * const listener = AppState.subscribe(({ state, updated }) => {
  *   // do something with the `State` instance that updated
+ *   // the entirety of your state
  * });
+ *
+ * // get the current application state
+ * const currentState = AppState.getState();
+ *
+ * // operate on an instance of state
+ * AppState.update("user", userState => ({
+ *   ...userState,
+ *   // your updates
+ * }));
  * ```
  */
 export const createGalena = <T extends Record<string, State<any>>>(

package/src/Logger.ts

@@ -22,7 +22,7 @@ export class Logger<T = any> extends Middleware {
   private previousState: T | null = null;
 
   override onBeforeUpdate(state: State<T>) {
-    this.previousState = state.getSnapshot();
+    this.previousState = state.getState();
   }
 
   override onUpdate(state: State<T>) {
@@ -40,7 +40,7 @@ export class Logger<T = any> extends Middleware {
     console.log(
       "   %cNext State    ",
       "color: rgb(17, 118, 249); font-weight: bold",
-      state.getSnapshot(),
+      state.getState(),
     );
   }