@figliolia/galena 3.0.3 → 4.0.1

package/README.md

@@ -2,26 +2,9 @@
 
 Lightning fast, framework agnostic state, that doesn't glue your state operations to your UI components!
 
-## Basic Usage
-
-```typescript
-import { State, createState } from "@figliolia/galena";
-
-const myState = new State(/* any value */);
-// or
-const myState = createState(/* any value */);
-
-const currentValue = myState.getSnapshot();
-const subscriber = myState.subscribe(nextValue => {});
-myState.set(/* new value */);
-myState.update(previousValue => /* new value */);
-
-// to reset state back to its original value
-myState.reset();
-
-// to unregister the subscription
-subscriber();
-```
+[State](#the-state-model)
+[Galena](#the-galena-model)
+[For use with react](#frameworks)
 
 ## Installation
 
@@ -38,20 +21,22 @@ npm i @figliolia/react-galena
 The instancable `State` object in Galena is a reactive wrapper around any value. You can use it to apply reactivity to large objects or simple values
 
 ```typescript
-import { State } from "@figliolia/galena";
+import { State, createState } from "@figliolia/galena";
 
-const MyState = new State(/* any value */, /* middleware */);
+const myState = new State(/* any value */, /* middleware */);
+// or
+const myState = createState(/* any value */, /* middleware */);
 
-const subscriber = MyState.subscribe(value => {
-  // do something with changed values
-});
+const currentValue = myState.getState();
+const subscriber = myState.subscribe(nextValue => {});
+myState.set(/* new value */);
+myState.update(previousValue => /* new value */);
 
-// to unsubscribe
-subscriber();
+// to reset state back to its original value
+myState.reset();
 
-MyState.set(/* new value */);
-MyState.update(previousValue => /* new value */);
-MyState.reset(); // reset state back to the initial value
+// to unregister the subscription
+subscriber();
 ```
 
 Instances of `State` are ultimately what compose all reactivity in Galena. They can exist as islands compose larger stateful model.
@@ -99,7 +84,10 @@ const UserState = AppState.get("user");
 // to operate
 UserState.update(state => /* next state */);
 // or
-AppState.update("user", state => /* next state */)
+AppState.update("user", state => /* next state */);
+
+// to get the current value of the state tree
+const state = AppState.getState();
 ```
 
 ### Beyond the Basics
@@ -181,7 +169,7 @@ export class Logger<T = any> extends Middleware<T> {
 
   override onBeforeUpdate(state: State<T>) {
     // capture the previous state before an update takes place
-    this.previousState = state.getSnapshot();
+    this.previousState = state.getState();
   }
 
   override onUpdate(state: State<T>) {
@@ -202,7 +190,7 @@ export class Logger<T = any> extends Middleware<T> {
     console.log(
       "   %cNext State    ",
       "color: rgb(17, 118, 249); font-weight: bold",
-      state.getSnapshot(),
+      state.getState(),
     );
   }
 

package/dist/API.cjs

@@ -0,0 +1,9 @@
+//#region src/API.ts
+var API = class {
+	middleware = [];
+	constructor(...middleware) {
+		this.registerMiddleware(...middleware);
+	}
+};
+//#endregion
+exports.API = API;

package/dist/API.d.cts

@@ -0,0 +1,13 @@
+import { Middleware } from "./Middleware.cjs";
+
+//#region src/API.d.ts
+declare abstract class API<T, E, M = T> {
+  readonly middleware: Middleware<M>[];
+  constructor(...middleware: Middleware<M>[]);
+  abstract getState(): T;
+  abstract subscribe(subscriber: (payload: E) => void): () => void;
+  abstract registerMiddleware(...middlewares: Middleware<M>[]): void;
+}
+//#endregion
+export { API };
+//# sourceMappingURL=API.d.cts.map

package/dist/API.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"API.d.cts","names":[],"sources":["../src/API.ts"],"mappings":";;;uBAEsB,GAAA,WAAc,CAAA;EAAA,SAClB,UAAA,EAAY,UAAA,CAAW,CAAA;iBACxB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,SAItB,QAAA,CAAA,GAAY,CAAA;EAAA,SACZ,SAAA,CAAU,UAAA,GAAa,OAAA,EAAS,CAAA;EAAA,SAChC,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,CAAA;AAAA"}

package/dist/API.d.mts

@@ -0,0 +1,13 @@
+import { Middleware } from "./Middleware.mjs";
+
+//#region src/API.d.ts
+declare abstract class API<T, E, M = T> {
+  readonly middleware: Middleware<M>[];
+  constructor(...middleware: Middleware<M>[]);
+  abstract getState(): T;
+  abstract subscribe(subscriber: (payload: E) => void): () => void;
+  abstract registerMiddleware(...middlewares: Middleware<M>[]): void;
+}
+//#endregion
+export { API };
+//# sourceMappingURL=API.d.mts.map

package/dist/API.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"API.d.mts","names":[],"sources":["../src/API.ts"],"mappings":";;;uBAEsB,GAAA,WAAc,CAAA;EAAA,SAClB,UAAA,EAAY,UAAA,CAAW,CAAA;iBACxB,UAAA,EAAY,UAAA,CAAW,CAAA;EAAA,SAItB,QAAA,CAAA,GAAY,CAAA;EAAA,SACZ,SAAA,CAAU,UAAA,GAAa,OAAA,EAAS,CAAA;EAAA,SAChC,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,CAAA;AAAA"}

package/dist/API.mjs

@@ -0,0 +1,11 @@
+//#region src/API.ts
+var API = class {
+	middleware = [];
+	constructor(...middleware) {
+		this.registerMiddleware(...middleware);
+	}
+};
+//#endregion
+export { API };
+
+//# sourceMappingURL=API.mjs.map

package/dist/API.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"API.mjs","names":[],"sources":["../src/API.ts"],"sourcesContent":["import type { Middleware } from \"./Middleware\";\n\nexport abstract class API<T, E, M = T> {\n  public readonly middleware: Middleware<M>[] = [];\n  constructor(...middleware: Middleware<M>[]) {\n    this.registerMiddleware(...middleware);\n  }\n\n  public abstract getState(): T;\n  public abstract subscribe(subscriber: (payload: E) => void): () => void;\n  public abstract registerMiddleware(...middlewares: Middleware<M>[]): void;\n}\n"],"mappings":";AAEA,IAAsB,MAAtB,MAAuC;CACrC,aAA8C,EAAE;CAChD,YAAY,GAAG,YAA6B;AAC1C,OAAK,mBAAmB,GAAG,WAAW"}

package/dist/Galena.cjs

@@ -1,3 +1,4 @@
+const require_API = require("./API.cjs");
 let _figliolia_event_emitter = require("@figliolia/event-emitter");
 //#region src/Galena.ts
 /**
@@ -20,20 +21,37 @@ let _figliolia_event_emitter = require("@figliolia/event-emitter");
 * }, ...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 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
+* }));
 * ```
 */
-var Galena = class {
+var Galena = class extends require_API.API {
 	Emitter = new _figliolia_event_emitter.EventEmitter();
 	constructor(state, ...middleware) {
+		super(...middleware);
 		this.state = state;
-		this.registerMiddleware(...middleware);
+	}
+	getState() {
+		const result = {};
+		for (const key in this.state) {
+			const state = key;
+			result[state] = this.state[key].getState();
+		}
+		return result;
 	}
 	/**
 	* Get
@@ -116,13 +134,22 @@ var Galena = class {
 * }, ...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 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
+* }));
 * ```
 */
 const createGalena = (...args) => {

package/dist/Galena.d.cts

@@ -1,6 +1,7 @@
-import { AppSubscriber, Setter, StateType, StateTypes } from "./types.cjs";
+import { AppSubscriber, GalenaSnapshot, GalenaState, Setter, StateType, StateTypes } from "./types.cjs";
 import { State } from "./State.cjs";
 import { Middleware } from "./Middleware.cjs";
+import { API } from "./API.cjs";
 
 //#region src/Galena.d.ts
 /**
@@ -23,19 +24,29 @@ import { Middleware } from "./Middleware.cjs";
  * }, ...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 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
+ * }));
  * ```
  */
-declare class Galena<T extends Record<string, State<any>>> {
+declare class Galena<T extends Record<string, State<any>>> extends API<GalenaState<T>, GalenaSnapshot<T>, StateTypes<T>> {
   readonly state: T;
   private Emitter;
   constructor(state: T, ...middleware: Middleware<StateTypes<T>>[]);
+  getState(): GalenaState<T>;
   /**
    * Get
    *
@@ -92,13 +103,22 @@ declare class Galena<T extends Record<string, State<any>>> {
  * }, ...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 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
+ * }));
  * ```
  */
 declare const createGalena: <T extends Record<string, State<any>>>(...args: ConstructorParameters<typeof Galena<T>>) => Galena<T>;

package/dist/Galena.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"Galena.d.cts","names":[],"sources":["../src/Galena.ts"],"mappings":";;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,MAAA,WAAiB,MAAA,SAAe,KAAA;EAAA,SAGzB,KAAA,EAAO,CAAA;EAAA,QAFjB,OAAA;cAEU,KAAA,EAAO,CAAA,KACpB,UAAA,EAAY,UAAA,CAAW,UAAA,CAAW,CAAA;EA0Ec;;;;;EAhE9C,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CAAY,GAAA,EAAK,CAAA,GAAC,CAAA,CAAA,CAAA;EAdV;;;;;EAuBpC,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CACjC,GAAA,EAAK,CAAA,EACL,KAAA,EAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAtBH;;;;;EAgCX,MAAA,WAAiB,OAAA,OAAc,CAAA,UAAA,CACpC,GAAA,EAAK,CAAA,EACL,OAAA,EAAS,MAAA,CAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAvBnB;;;;;;;;EAoCJ,SAAA,GAAa,UAAA,EAAY,aAAA,CAAc,CAAA;EA3BzB;;;;;;EAuDd,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,UAAA,CAAW,CAAA;EAAA,QAMxD,IAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAoCV;;;;;;;cAAa,YAAA,aAA0B,MAAA,SAAe,KAAA,WACjD,IAAA,EAAM,qBAAA,QAA6B,MAAA,CAAO,CAAA,OAAG,MAAA,CAAA,CAAA"}
+{"version":3,"file":"Galena.d.cts","names":[],"sources":["../src/Galena.ts"],"mappings":";;;;;;;;AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,MAAA,WAAiB,MAAA,SAAe,KAAA,gBAAqB,GAAA,CAChE,WAAA,CAAY,CAAA,GACZ,cAAA,CAAe,CAAA,GACf,UAAA,CAAW,CAAA;EAAA,SAIO,KAAA,EAAO,CAAA;EAAA,QAFjB,OAAA;cAEU,KAAA,EAAO,CAAA,KACpB,UAAA,EAAY,UAAA,CAAW,UAAA,CAAW,CAAA;EAKhC,QAAA,CAAA,GAAQ,WAAA,CAAA,CAAA;EAbiD;;;;;EA2BzD,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CAAY,GAAA,EAAK,CAAA,GAAC,CAAA,CAAA,CAAA;EA3BW;;;;;EAoCzD,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CACjC,GAAA,EAAK,CAAA,EACL,KAAA,EAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAnCV;;;;;EA6CJ,MAAA,WAAiB,OAAA,OAAc,CAAA,UAAA,CACpC,GAAA,EAAK,CAAA,EACL,OAAA,EAAS,MAAA,CAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EA3CZ;;;;;;;;EAwDX,SAAA,GAAa,UAAA,EAAY,aAAA,CAAc,CAAA;EApCnC;;;;;;EAgEJ,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,UAAA,CAAW,CAAA;EAAA,QAMxD,IAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CV;;;;;;;cAAa,YAAA,aAA0B,MAAA,SAAe,KAAA,WACjD,IAAA,EAAM,qBAAA,QAA6B,MAAA,CAAO,CAAA,OAAG,MAAA,CAAA,CAAA"}

package/dist/Galena.d.mts

@@ -1,6 +1,7 @@
-import { AppSubscriber, Setter, StateType, StateTypes } from "./types.mjs";
+import { AppSubscriber, GalenaSnapshot, GalenaState, Setter, StateType, StateTypes } from "./types.mjs";
 import { State } from "./State.mjs";
 import { Middleware } from "./Middleware.mjs";
+import { API } from "./API.mjs";
 
 //#region src/Galena.d.ts
 /**
@@ -23,19 +24,29 @@ import { Middleware } from "./Middleware.mjs";
  * }, ...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 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
+ * }));
  * ```
  */
-declare class Galena<T extends Record<string, State<any>>> {
+declare class Galena<T extends Record<string, State<any>>> extends API<GalenaState<T>, GalenaSnapshot<T>, StateTypes<T>> {
   readonly state: T;
   private Emitter;
   constructor(state: T, ...middleware: Middleware<StateTypes<T>>[]);
+  getState(): GalenaState<T>;
   /**
    * Get
    *
@@ -92,13 +103,22 @@ declare class Galena<T extends Record<string, State<any>>> {
  * }, ...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 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
+ * }));
  * ```
  */
 declare const createGalena: <T extends Record<string, State<any>>>(...args: ConstructorParameters<typeof Galena<T>>) => Galena<T>;

package/dist/Galena.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Galena.d.mts","names":[],"sources":["../src/Galena.ts"],"mappings":";;;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,MAAA,WAAiB,MAAA,SAAe,KAAA;EAAA,SAGzB,KAAA,EAAO,CAAA;EAAA,QAFjB,OAAA;cAEU,KAAA,EAAO,CAAA,KACpB,UAAA,EAAY,UAAA,CAAW,UAAA,CAAW,CAAA;EA0Ec;;;;;EAhE9C,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CAAY,GAAA,EAAK,CAAA,GAAC,CAAA,CAAA,CAAA;EAdV;;;;;EAuBpC,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CACjC,GAAA,EAAK,CAAA,EACL,KAAA,EAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAtBH;;;;;EAgCX,MAAA,WAAiB,OAAA,OAAc,CAAA,UAAA,CACpC,GAAA,EAAK,CAAA,EACL,OAAA,EAAS,MAAA,CAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAvBnB;;;;;;;;EAoCJ,SAAA,GAAa,UAAA,EAAY,aAAA,CAAc,CAAA;EA3BzB;;;;;;EAuDd,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,UAAA,CAAW,CAAA;EAAA,QAMxD,IAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAoCV;;;;;;;cAAa,YAAA,aAA0B,MAAA,SAAe,KAAA,WACjD,IAAA,EAAM,qBAAA,QAA6B,MAAA,CAAO,CAAA,OAAG,MAAA,CAAA,CAAA"}
+{"version":3,"file":"Galena.d.mts","names":[],"sources":["../src/Galena.ts"],"mappings":";;;;;;;;AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,MAAA,WAAiB,MAAA,SAAe,KAAA,gBAAqB,GAAA,CAChE,WAAA,CAAY,CAAA,GACZ,cAAA,CAAe,CAAA,GACf,UAAA,CAAW,CAAA;EAAA,SAIO,KAAA,EAAO,CAAA;EAAA,QAFjB,OAAA;cAEU,KAAA,EAAO,CAAA,KACpB,UAAA,EAAY,UAAA,CAAW,UAAA,CAAW,CAAA;EAKhC,QAAA,CAAA,GAAQ,WAAA,CAAA,CAAA;EAbiD;;;;;EA2BzD,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CAAY,GAAA,EAAK,CAAA,GAAC,CAAA,CAAA,CAAA;EA3BW;;;;;EAoCzD,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CACjC,GAAA,EAAK,CAAA,EACL,KAAA,EAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EAnCV;;;;;EA6CJ,MAAA,WAAiB,OAAA,OAAc,CAAA,UAAA,CACpC,GAAA,EAAK,CAAA,EACL,OAAA,EAAS,MAAA,CAAO,SAAA,CAAU,CAAA,CAAE,CAAA;EA3CZ;;;;;;;;EAwDX,SAAA,GAAa,UAAA,EAAY,aAAA,CAAc,CAAA;EApCnC;;;;;;EAgEJ,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,UAAA,CAAW,CAAA;EAAA,QAMxD,IAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CV;;;;;;;cAAa,YAAA,aAA0B,MAAA,SAAe,KAAA,WACjD,IAAA,EAAM,qBAAA,QAA6B,MAAA,CAAO,CAAA,OAAG,MAAA,CAAA,CAAA"}

package/dist/Galena.mjs

@@ -1,3 +1,4 @@
+import { API } from "./API.mjs";
 import { EventEmitter } from "@figliolia/event-emitter";
 //#region src/Galena.ts
 /**
@@ -20,20 +21,37 @@ import { EventEmitter } from "@figliolia/event-emitter";
 * }, ...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 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
+* }));
 * ```
 */
-var Galena = class {
+var Galena = class extends API {
 	Emitter = new EventEmitter();
 	constructor(state, ...middleware) {
+		super(...middleware);
 		this.state = state;
-		this.registerMiddleware(...middleware);
+	}
+	getState() {
+		const result = {};
+		for (const key in this.state) {
+			const state = key;
+			result[state] = this.state[key].getState();
+		}
+		return result;
 	}
 	/**
 	* Get
@@ -116,13 +134,22 @@ var Galena = class {
 * }, ...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 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
+* }));
 * ```
 */
 const createGalena = (...args) => {

package/dist/Galena.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Galena.mjs","names":[],"sources":["../src/Galena.ts"],"sourcesContent":["import { EventEmitter } from \"@figliolia/event-emitter\";\nimport type { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\nimport type {\n  AppSubscriber,\n  GalenaSnapshot,\n  Setter,\n  StateType,\n  StateTypes,\n} from \"./types\";\n\n/**\n * ### Galena\n *\n * Galena instances are designed to house one or more units of `State`\n * and exist as a pseudo global application state.\n *\n * By design, each of its `State` units have isolated reactivity\n * that prevents entire state trees from updating when a single\n * unit changes.\n *\n * ```typescript\n * import { Galena } from \"@figliolia/galena\";\n *\n * const AppState = new Galena({\n *   user: new State(\"<user-stuff>\"),\n *   business: new State(\"<business-logic-stuff>\")\n *   // your reactive instances\n * }, ...middleware);\n *\n * // to retreive and work with an individual unit\n * const myUnit = AppState.get(\"<key>\"); // Returns State<T>\n *\n * // to run a callback anytime a unit of state changes\n * const listener = AppState.subscribe(({ state, updated }) => {\n *   // do something with the `State` instance that updated\n *   // the entirety of your state\n * });\n * ```\n */\nexport class Galena<T extends Record<string, State<any>>> {\n  private Emitter = new EventEmitter<{ change: GalenaSnapshot<T> }>();\n  constructor(\n    public readonly state: T,\n    ...middleware: Middleware<StateTypes<T>>[]\n  ) {\n    this.registerMiddleware(...middleware);\n  }\n\n  /**\n   * Get\n   *\n   * Returns a connected State instance by key\n   */\n  public get<K extends Extract<keyof T, string>>(key: K) {\n    return this.state[key];\n  }\n\n  /**\n   * Set\n   *\n   * Sets a connected State instance's state by key\n   */\n  public set<K extends Extract<keyof T, string>>(\n    key: K,\n    value: StateType<T[K]>,\n  ) {\n    return this.get(key).set(value);\n  }\n\n  /**\n   * Update\n   *\n   * Invokes a connected State instance's update method key\n   */\n  public update<K extends Extract<keyof T, string>>(\n    key: K,\n    updater: Setter<StateType<T[K]>>,\n  ) {\n    return this.get(key).update(updater);\n  }\n\n  /**\n   * Subscribe\n   *\n   * Listen for changes on your Galena instnace. Your provided\n   * callback will be invoked each time an attached state instance\n   * changes. To your callback will be provided the `updated` state\n   * instance, along with the entire `state` tree\n   */\n  public subscribe = (subscriber: AppSubscriber<T>) => {\n    const ID = this.Emitter.on(\"change\", subscriber);\n    const unsubscribers: (() => void)[] = [];\n    for (const key in this.state) {\n      const instance = this.state[key];\n      if (!instance) {\n        continue;\n      }\n      unsubscribers.push(\n        instance.subscribe(() =>\n          this.emit({ state: this.state, updated: instance }),\n        ),\n      );\n    }\n    return () => {\n      this.Emitter.off(\"change\", ID);\n      while (unsubscribers.length) {\n        unsubscribers.pop?.()?.();\n      }\n    };\n  };\n\n  /**\n   * Register Middleware\n   *\n   * Adds middleware instances to each of the connected\n   * `State` instances\n   */\n  public registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]) {\n    for (const key in this.state) {\n      this.state[key]?.registerMiddleware?.(...middlewares);\n    }\n  }\n\n  private emit<K extends Extract<keyof T, string>>(\n    event: GalenaSnapshot<T, K>,\n  ) {\n    this.Emitter.emit(\"change\", event);\n  }\n}\n\n/**\n * ### createGalena\n *\n * Galena instances are designed to house one or more units of `State`\n * and exist as a pseudo global application state.\n *\n * By design, each of its `State` units have isolated reactivity\n * that prevents entire state trees from updating when a single\n * unit changes.\n *\n * ```typescript\n * import { Galena } from \"@figliolia/galena\";\n *\n * const AppState = new Galena({\n *   user: new State(\"<user-stuff>\"),\n *   business: new State(\"<business-logic-stuff>\")\n *   // your reactive instances\n * }, ...middleware);\n *\n * // to retreive and work with an individual unit\n * const myUnit = AppState.get(\"<key>\"); // Returns State<T>\n *\n * // to run a callback anytime a unit of state changes\n * const listener = AppState.subscribe(({ state, updated }) => {\n *   // do something with the `State` instance that updated\n *   // the entirety of your state\n * });\n * ```\n */\nexport const createGalena = <T extends Record<string, State<any>>>(\n  ...args: ConstructorParameters<typeof Galena<T>>\n) => {\n  return new Galena(...args);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAa,SAAb,MAA0D;CACxD,UAAkB,IAAI,cAA6C;CACnE,YACE,OACA,GAAG,YACH;AAFgB,OAAA,QAAA;AAGhB,OAAK,mBAAmB,GAAG,WAAW;;;;;;;CAQxC,IAA+C,KAAQ;AACrD,SAAO,KAAK,MAAM;;;;;;;CAQpB,IACE,KACA,OACA;AACA,SAAO,KAAK,IAAI,IAAI,CAAC,IAAI,MAAM;;;;;;;CAQjC,OACE,KACA,SACA;AACA,SAAO,KAAK,IAAI,IAAI,CAAC,OAAO,QAAQ;;;;;;;;;;CAWtC,aAAoB,eAAiC;EACnD,MAAM,KAAK,KAAK,QAAQ,GAAG,UAAU,WAAW;EAChD,MAAM,gBAAgC,EAAE;AACxC,OAAK,MAAM,OAAO,KAAK,OAAO;GAC5B,MAAM,WAAW,KAAK,MAAM;AAC5B,OAAI,CAAC,SACH;AAEF,iBAAc,KACZ,SAAS,gBACP,KAAK,KAAK;IAAE,OAAO,KAAK;IAAO,SAAS;IAAU,CAAC,CACpD,CACF;;AAEH,eAAa;AACX,QAAK,QAAQ,IAAI,UAAU,GAAG;AAC9B,UAAO,cAAc,OACnB,eAAc,OAAO,IAAI;;;;;;;;;CAW/B,mBAA0B,GAAG,aAA0C;AACrE,OAAK,MAAM,OAAO,KAAK,MACrB,MAAK,MAAM,MAAM,qBAAqB,GAAG,YAAY;;CAIzD,KACE,OACA;AACA,OAAK,QAAQ,KAAK,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCtC,MAAa,gBACX,GAAG,SACA;AACH,QAAO,IAAI,OAAO,GAAG,KAAK"}
+{"version":3,"file":"Galena.mjs","names":[],"sources":["../src/Galena.ts"],"sourcesContent":["import { EventEmitter } from \"@figliolia/event-emitter\";\nimport { API } from \"./API\";\nimport type { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\nimport type {\n  AppSubscriber,\n  GalenaSnapshot,\n  GalenaState,\n  Setter,\n  StateType,\n  StateTypes,\n} from \"./types\";\n\n/**\n * ### Galena\n *\n * Galena instances are designed to house one or more units of `State`\n * and exist as a pseudo global application state.\n *\n * By design, each of its `State` units have isolated reactivity\n * that prevents entire state trees from updating when a single\n * unit changes.\n *\n * ```typescript\n * import { Galena } from \"@figliolia/galena\";\n *\n * const AppState = new Galena({\n *   user: new State(\"<user-stuff>\"),\n *   business: new State(\"<business-logic-stuff>\")\n *   // your reactive instances\n * }, ...middleware);\n *\n * // to retreive and work with an individual unit\n * const userState = AppState.get(\"user\"); // Returns State<T>\n *\n * // to run a callback anytime a unit of state changes\n * const listener = AppState.subscribe(({ state, updated }) => {\n *   // do something with the `State` instance that updated\n *   // the entirety of your state\n * });\n *\n * // get the current application state\n * const currentState = AppState.getState();\n *\n * // operate on an instance of state\n * AppState.update(\"user\", userState => ({\n *   ...userState,\n *   // your updates\n * }));\n * ```\n */\nexport class Galena<T extends Record<string, State<any>>> extends API<\n  GalenaState<T>,\n  GalenaSnapshot<T>,\n  StateTypes<T>\n> {\n  private Emitter = new EventEmitter<{ change: GalenaSnapshot<T> }>();\n  constructor(\n    public readonly state: T,\n    ...middleware: Middleware<StateTypes<T>>[]\n  ) {\n    super(...middleware);\n  }\n\n  public getState() {\n    const result = {} as GalenaState<T>;\n    for (const key in this.state) {\n      const state = key as keyof T;\n      result[state] = this.state[key].getState();\n    }\n    return result;\n  }\n\n  /**\n   * Get\n   *\n   * Returns a connected State instance by key\n   */\n  public get<K extends Extract<keyof T, string>>(key: K) {\n    return this.state[key];\n  }\n\n  /**\n   * Set\n   *\n   * Sets a connected State instance's state by key\n   */\n  public set<K extends Extract<keyof T, string>>(\n    key: K,\n    value: StateType<T[K]>,\n  ) {\n    return this.get(key).set(value);\n  }\n\n  /**\n   * Update\n   *\n   * Invokes a connected State instance's update method key\n   */\n  public update<K extends Extract<keyof T, string>>(\n    key: K,\n    updater: Setter<StateType<T[K]>>,\n  ) {\n    return this.get(key).update(updater);\n  }\n\n  /**\n   * Subscribe\n   *\n   * Listen for changes on your Galena instnace. Your provided\n   * callback will be invoked each time an attached state instance\n   * changes. To your callback will be provided the `updated` state\n   * instance, along with the entire `state` tree\n   */\n  public subscribe = (subscriber: AppSubscriber<T>) => {\n    const ID = this.Emitter.on(\"change\", subscriber);\n    const unsubscribers: (() => void)[] = [];\n    for (const key in this.state) {\n      const instance = this.state[key];\n      if (!instance) {\n        continue;\n      }\n      unsubscribers.push(\n        instance.subscribe(() =>\n          this.emit({ state: this.state, updated: instance }),\n        ),\n      );\n    }\n    return () => {\n      this.Emitter.off(\"change\", ID);\n      while (unsubscribers.length) {\n        unsubscribers.pop?.()?.();\n      }\n    };\n  };\n\n  /**\n   * Register Middleware\n   *\n   * Adds middleware instances to each of the connected\n   * `State` instances\n   */\n  public registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]) {\n    for (const key in this.state) {\n      this.state[key]?.registerMiddleware?.(...middlewares);\n    }\n  }\n\n  private emit<K extends Extract<keyof T, string>>(\n    event: GalenaSnapshot<T, K>,\n  ) {\n    this.Emitter.emit(\"change\", event);\n  }\n}\n\n/**\n * ### createGalena\n *\n * Galena instances are designed to house one or more units of `State`\n * and exist as a pseudo global application state.\n *\n * By design, each of its `State` units have isolated reactivity\n * that prevents entire state trees from updating when a single\n * unit changes.\n *\n * ```typescript\n * import { Galena } from \"@figliolia/galena\";\n *\n * const AppState = new Galena({\n *   user: new State(\"<user-stuff>\"),\n *   business: new State(\"<business-logic-stuff>\")\n *   // your reactive instances\n * }, ...middleware);\n *\n * // to retreive and work with an individual unit\n * const userState = AppState.get(\"user\"); // Returns State<T>\n *\n * // to run a callback anytime a unit of state changes\n * const listener = AppState.subscribe(({ state, updated }) => {\n *   // do something with the `State` instance that updated\n *   // the entirety of your state\n * });\n *\n * // get the current application state\n * const currentState = AppState.getState();\n *\n * // operate on an instance of state\n * AppState.update(\"user\", userState => ({\n *   ...userState,\n *   // your updates\n * }));\n * ```\n */\nexport const createGalena = <T extends Record<string, State<any>>>(\n  ...args: ConstructorParameters<typeof Galena<T>>\n) => {\n  return new Galena(...args);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,SAAb,cAAkE,IAIhE;CACA,UAAkB,IAAI,cAA6C;CACnE,YACE,OACA,GAAG,YACH;AACA,QAAM,GAAG,WAAW;AAHJ,OAAA,QAAA;;CAMlB,WAAkB;EAChB,MAAM,SAAS,EAAE;AACjB,OAAK,MAAM,OAAO,KAAK,OAAO;GAC5B,MAAM,QAAQ;AACd,UAAO,SAAS,KAAK,MAAM,KAAK,UAAU;;AAE5C,SAAO;;;;;;;CAQT,IAA+C,KAAQ;AACrD,SAAO,KAAK,MAAM;;;;;;;CAQpB,IACE,KACA,OACA;AACA,SAAO,KAAK,IAAI,IAAI,CAAC,IAAI,MAAM;;;;;;;CAQjC,OACE,KACA,SACA;AACA,SAAO,KAAK,IAAI,IAAI,CAAC,OAAO,QAAQ;;;;;;;;;;CAWtC,aAAoB,eAAiC;EACnD,MAAM,KAAK,KAAK,QAAQ,GAAG,UAAU,WAAW;EAChD,MAAM,gBAAgC,EAAE;AACxC,OAAK,MAAM,OAAO,KAAK,OAAO;GAC5B,MAAM,WAAW,KAAK,MAAM;AAC5B,OAAI,CAAC,SACH;AAEF,iBAAc,KACZ,SAAS,gBACP,KAAK,KAAK;IAAE,OAAO,KAAK;IAAO,SAAS;IAAU,CAAC,CACpD,CACF;;AAEH,eAAa;AACX,QAAK,QAAQ,IAAI,UAAU,GAAG;AAC9B,UAAO,cAAc,OACnB,eAAc,OAAO,IAAI;;;;;;;;;CAW/B,mBAA0B,GAAG,aAA0C;AACrE,OAAK,MAAM,OAAO,KAAK,MACrB,MAAK,MAAM,MAAM,qBAAqB,GAAG,YAAY;;CAIzD,KACE,OACA;AACA,OAAK,QAAQ,KAAK,UAAU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CtC,MAAa,gBACX,GAAG,SACA;AACH,QAAO,IAAI,OAAO,GAAG,KAAK"}

package/dist/Logger.cjs

@@ -20,12 +20,12 @@ const require_Middleware = require("./Middleware.cjs");
 var Logger = class extends require_Middleware.Middleware {
 	previousState = null;
 	onBeforeUpdate(state) {
-		this.previousState = state.getSnapshot();
+		this.previousState = state.getState();
 	}
 	onUpdate(state) {
 		console.log("%cMutation:", "color: rgb(187, 186, 186); font-weight: bold", "@", this.time);
 		console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
-		console.log("   %cNext State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+		console.log("   %cNext State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getState());
 	}
 	/**
 	* Time

package/dist/Logger.mjs

@@ -20,12 +20,12 @@ import { Middleware } from "./Middleware.mjs";
 var Logger = class extends Middleware {
 	previousState = null;
 	onBeforeUpdate(state) {
-		this.previousState = state.getSnapshot();
+		this.previousState = state.getState();
 	}
 	onUpdate(state) {
 		console.log("%cMutation:", "color: rgb(187, 186, 186); font-weight: bold", "@", this.time);
 		console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
-		console.log("   %cNext State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+		console.log("   %cNext State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getState());
 	}
 	/**
 	* Time

package/dist/Logger.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Logger.mjs","names":[],"sources":["../src/Logger.ts"],"sourcesContent":["import { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\n\n/**\n * Logger\n *\n * A middleware for Redux-style logging! Each state transition\n * will log to the console the `State` instance that changed\n * along with a before and after snapshot of the current state:\n *\n * ```typescript\n * const AppState = new Galena({}, new Logger());\n * // or\n * AppState.registerMiddlerware(new Logger());\n * // or\n * const MyState = new State(4, new Logger());\n * // or\n * MyState.registerMiddleware(new Logger());\n * ```\n */\nexport class Logger<T = any> extends Middleware {\n  private previousState: T | null = null;\n\n  override onBeforeUpdate(state: State<T>) {\n    this.previousState = state.getSnapshot();\n  }\n\n  override onUpdate(state: State<T>) {\n    console.log(\n      \"%cMutation:\",\n      \"color: rgb(187, 186, 186); font-weight: bold\",\n      \"@\",\n      this.time,\n    );\n    console.log(\n      \"   %cPrevious State\",\n      \"color: #26ad65; font-weight: bold\",\n      this.previousState,\n    );\n    console.log(\n      \"   %cNext State    \",\n      \"color: rgb(17, 118, 249); font-weight: bold\",\n      state.getSnapshot(),\n    );\n  }\n\n  /**\n   * Time\n   *\n   * Returns the time in which a given state transition completed\n   */\n  private get time() {\n    const date = new Date();\n    const mHours = date.getHours();\n    const hours = mHours > 12 ? mHours - 12 : mHours;\n    const mins = date.getMinutes();\n    const minutes = mins.toString().length === 1 ? `0${mins}` : mins;\n    const secs = date.getSeconds();\n    const seconds = secs.toString().length === 1 ? `0${secs}` : secs;\n    const milliseconds = date.getMilliseconds();\n    return `${hours}:${minutes}:${seconds}:${milliseconds}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,IAAa,SAAb,cAAqC,WAAW;CAC9C,gBAAkC;CAElC,eAAwB,OAAiB;AACvC,OAAK,gBAAgB,MAAM,aAAa;;CAG1C,SAAkB,OAAiB;AACjC,UAAQ,IACN,eACA,gDACA,KACA,KAAK,KACN;AACD,UAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,UAAQ,IACN,uBACA,+CACA,MAAM,aAAa,CACpB;;;;;;;CAQH,IAAY,OAAO;EACjB,MAAM,uBAAO,IAAI,MAAM;EACvB,MAAM,SAAS,KAAK,UAAU;EAC9B,MAAM,QAAQ,SAAS,KAAK,SAAS,KAAK;EAC1C,MAAM,OAAO,KAAK,YAAY;EAC9B,MAAM,UAAU,KAAK,UAAU,CAAC,WAAW,IAAI,IAAI,SAAS;EAC5D,MAAM,OAAO,KAAK,YAAY;AAG9B,SAAO,GAAG,MAAM,GAAG,QAAQ,GAFX,KAAK,UAAU,CAAC,WAAW,IAAI,IAAI,SAAS,KAEtB,GADjB,KAAK,iBAAiB"}
+{"version":3,"file":"Logger.mjs","names":[],"sources":["../src/Logger.ts"],"sourcesContent":["import { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\n\n/**\n * Logger\n *\n * A middleware for Redux-style logging! Each state transition\n * will log to the console the `State` instance that changed\n * along with a before and after snapshot of the current state:\n *\n * ```typescript\n * const AppState = new Galena({}, new Logger());\n * // or\n * AppState.registerMiddlerware(new Logger());\n * // or\n * const MyState = new State(4, new Logger());\n * // or\n * MyState.registerMiddleware(new Logger());\n * ```\n */\nexport class Logger<T = any> extends Middleware {\n  private previousState: T | null = null;\n\n  override onBeforeUpdate(state: State<T>) {\n    this.previousState = state.getState();\n  }\n\n  override onUpdate(state: State<T>) {\n    console.log(\n      \"%cMutation:\",\n      \"color: rgb(187, 186, 186); font-weight: bold\",\n      \"@\",\n      this.time,\n    );\n    console.log(\n      \"   %cPrevious State\",\n      \"color: #26ad65; font-weight: bold\",\n      this.previousState,\n    );\n    console.log(\n      \"   %cNext State    \",\n      \"color: rgb(17, 118, 249); font-weight: bold\",\n      state.getState(),\n    );\n  }\n\n  /**\n   * Time\n   *\n   * Returns the time in which a given state transition completed\n   */\n  private get time() {\n    const date = new Date();\n    const mHours = date.getHours();\n    const hours = mHours > 12 ? mHours - 12 : mHours;\n    const mins = date.getMinutes();\n    const minutes = mins.toString().length === 1 ? `0${mins}` : mins;\n    const secs = date.getSeconds();\n    const seconds = secs.toString().length === 1 ? `0${secs}` : secs;\n    const milliseconds = date.getMilliseconds();\n    return `${hours}:${minutes}:${seconds}:${milliseconds}`;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA,IAAa,SAAb,cAAqC,WAAW;CAC9C,gBAAkC;CAElC,eAAwB,OAAiB;AACvC,OAAK,gBAAgB,MAAM,UAAU;;CAGvC,SAAkB,OAAiB;AACjC,UAAQ,IACN,eACA,gDACA,KACA,KAAK,KACN;AACD,UAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,UAAQ,IACN,uBACA,+CACA,MAAM,UAAU,CACjB;;;;;;;CAQH,IAAY,OAAO;EACjB,MAAM,uBAAO,IAAI,MAAM;EACvB,MAAM,SAAS,KAAK,UAAU;EAC9B,MAAM,QAAQ,SAAS,KAAK,SAAS,KAAK;EAC1C,MAAM,OAAO,KAAK,YAAY;EAC9B,MAAM,UAAU,KAAK,UAAU,CAAC,WAAW,IAAI,IAAI,SAAS;EAC5D,MAAM,OAAO,KAAK,YAAY;AAG9B,SAAO,GAAG,MAAM,GAAG,QAAQ,GAFX,KAAK,UAAU,CAAC,WAAW,IAAI,IAAI,SAAS,KAEtB,GADjB,KAAK,iBAAiB"}

package/dist/Middleware.cjs

@@ -18,7 +18,7 @@
 *
 *   public override onBeforeUpdate(state: State<T>) {
 *     this.startTime = performance.now();
-*     this.previousState = state.getSnapshot();
+*     this.previousState = state.getState();
 *   }
 *
 *   public override onUpdate(state: T) {
@@ -26,7 +26,7 @@
 *     if(diff >= this.threshold) {
 *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);
 *       console.log('Previous state', this.previousState);
-*       console.log('Current state', state.getSnapshot());
+*       console.log('Current state', state.getState());
 *     }
 *   }
 * }

package/dist/Middleware.d.cts

@@ -20,7 +20,7 @@ import { State } from "./State.cjs";
  *
  *   public override onBeforeUpdate(state: State<T>) {
  *     this.startTime = performance.now();
- *     this.previousState = state.getSnapshot();
+ *     this.previousState = state.getState();
  *   }
  *
  *   public override onUpdate(state: T) {
@@ -28,7 +28,7 @@ import { State } from "./State.cjs";
  *     if(diff >= this.threshold) {
  *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);
  *       console.log('Previous state', this.previousState);
- *       console.log('Current state', state.getSnapshot());
+ *       console.log('Current state', state.getState());
  *     }
  *   }
  * }

package/dist/Middleware.d.mts

@@ -20,7 +20,7 @@ import { State } from "./State.mjs";
  *
  *   public override onBeforeUpdate(state: State<T>) {
  *     this.startTime = performance.now();
- *     this.previousState = state.getSnapshot();
+ *     this.previousState = state.getState();
  *   }
  *
  *   public override onUpdate(state: T) {
@@ -28,7 +28,7 @@ import { State } from "./State.mjs";
  *     if(diff >= this.threshold) {
  *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);
  *       console.log('Previous state', this.previousState);
- *       console.log('Current state', state.getSnapshot());
+ *       console.log('Current state', state.getState());
  *     }
  *   }
  * }

package/dist/Middleware.mjs

@@ -18,7 +18,7 @@
 *
 *   public override onBeforeUpdate(state: State<T>) {
 *     this.startTime = performance.now();
-*     this.previousState = state.getSnapshot();
+*     this.previousState = state.getState();
 *   }
 *
 *   public override onUpdate(state: T) {
@@ -26,7 +26,7 @@
 *     if(diff >= this.threshold) {
 *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);
 *       console.log('Previous state', this.previousState);
-*       console.log('Current state', state.getSnapshot());
+*       console.log('Current state', state.getState());
 *     }
 *   }
 * }

package/dist/Middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Middleware.mjs","names":[],"sources":["../src/Middleware.ts"],"sourcesContent":["import type { State } from \"./State\";\n\n/**\n * Middleware\n *\n * Galena's middleware API is designed to provide hooks\n * for state changes that you can tap into to run your\n * own logic.\n *\n * Middleware is great for logging, analytics, and profiling:\n *\n * ```typescript\n * export class Profiler<T = any> extends Middleware<T> {\n *   private previousState: T | null = null;\n *   private startTime: null | number = null;\n *   constructor(public readonly threshold: number = 16) {\n *     super();\n *   }\n *\n *   public override onBeforeUpdate(state: State<T>) {\n *     this.startTime = performance.now();\n *     this.previousState = state.getSnapshot();\n *   }\n *\n *   public override onUpdate(state: T) {\n *     const diff = performance.now() - this.startTime;\n *     if(diff >= this.threshold) {\n *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);\n *       console.log('Previous state', this.previousState);\n *       console.log('Current state', state.getSnapshot());\n *     }\n *   }\n * }\n * ```\n *\n * To register your middleware, simply add it when constructing\n * a `State` or `Galena` instance.\n *\n * ```typescript\n * import { State } from \"@figliolia/galena\";\n * import { Profiler } from './myProfiler';\n *\n * const myState = new State(5, new Profiler());\n * ```\n */\nexport class Middleware<T = any> {\n  /**\n   * On Before Update\n   *\n   * Executes prior to a `State` instance being updated.\n   * Receives the state prior to its update as a parameter\n   */\n  public onBeforeUpdate(_state: State<T>) {}\n\n  /**\n   * On Update\n   *\n   * Executes after a `State` instance has been update.\n   * Receives the most recent state as a parameter\n   */\n  public onUpdate(_state: State<T>) {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,aAAb,MAAiC;;;;;;;CAO/B,eAAsB,QAAkB;;;;;;;CAQxC,SAAgB,QAAkB"}
+{"version":3,"file":"Middleware.mjs","names":[],"sources":["../src/Middleware.ts"],"sourcesContent":["import type { State } from \"./State\";\n\n/**\n * Middleware\n *\n * Galena's middleware API is designed to provide hooks\n * for state changes that you can tap into to run your\n * own logic.\n *\n * Middleware is great for logging, analytics, and profiling:\n *\n * ```typescript\n * export class Profiler<T = any> extends Middleware<T> {\n *   private previousState: T | null = null;\n *   private startTime: null | number = null;\n *   constructor(public readonly threshold: number = 16) {\n *     super();\n *   }\n *\n *   public override onBeforeUpdate(state: State<T>) {\n *     this.startTime = performance.now();\n *     this.previousState = state.getState();\n *   }\n *\n *   public override onUpdate(state: T) {\n *     const diff = performance.now() - this.startTime;\n *     if(diff >= this.threshold) {\n *       console.warn(`A slow state transition was detected when transitioning the following piece of state`);\n *       console.log('Previous state', this.previousState);\n *       console.log('Current state', state.getState());\n *     }\n *   }\n * }\n * ```\n *\n * To register your middleware, simply add it when constructing\n * a `State` or `Galena` instance.\n *\n * ```typescript\n * import { State } from \"@figliolia/galena\";\n * import { Profiler } from './myProfiler';\n *\n * const myState = new State(5, new Profiler());\n * ```\n */\nexport class Middleware<T = any> {\n  /**\n   * On Before Update\n   *\n   * Executes prior to a `State` instance being updated.\n   * Receives the state prior to its update as a parameter\n   */\n  public onBeforeUpdate(_state: State<T>) {}\n\n  /**\n   * On Update\n   *\n   * Executes after a `State` instance has been update.\n   * Receives the most recent state as a parameter\n   */\n  public onUpdate(_state: State<T>) {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,aAAb,MAAiC;;;;;;;CAO/B,eAAsB,QAAkB;;;;;;;CAQxC,SAAgB,QAAkB"}

package/dist/Profiler.cjs

@@ -25,7 +25,7 @@ var Profiler = class extends require_Middleware.Middleware {
 	}
 	onBeforeUpdate(state) {
 		this.startTime = performance.now();
-		this.previousState = state.getSnapshot();
+		this.previousState = state.getState();
 	}
 	onUpdate(state) {
 		if (this.startTime === null) return;
@@ -33,7 +33,7 @@ var Profiler = class extends require_Middleware.Middleware {
 		if (diff >= this.threshold) {
 			console.warn(`A slow state transition of ${diff.toFixed(1)}ms was detected when transitioning the following piece of state`);
 			console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
-			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getState());
 		}
 	}
 };

package/dist/Profiler.mjs

@@ -25,7 +25,7 @@ var Profiler = class extends Middleware {
 	}
 	onBeforeUpdate(state) {
 		this.startTime = performance.now();
-		this.previousState = state.getSnapshot();
+		this.previousState = state.getState();
 	}
 	onUpdate(state) {
 		if (this.startTime === null) return;
@@ -33,7 +33,7 @@ var Profiler = class extends Middleware {
 		if (diff >= this.threshold) {
 			console.warn(`A slow state transition of ${diff.toFixed(1)}ms was detected when transitioning the following piece of state`);
 			console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
-			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getState());
 		}
 	}
 };