@figliolia/galena 3.0.2 → 4.0.0

package/dist/Galena.d.mts

@@ -1,77 +1,124 @@
-import { AppSubscriber, 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
 /**
- * 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
+ * }));
  * ```
  */
-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
+   *
+   * Returns a connected State instance by key
+   */
   get<K extends Extract<keyof T, string>>(key: K): T[K];
+  /**
+   * Set
+   *
+   * Sets a connected State instance's state by key
+   */
+  set<K extends Extract<keyof T, string>>(key: K, value: StateType<T[K]>): void;
+  /**
+   * Update
+   *
+   * Invokes a connected State instance's update method key
+   */
+  update<K extends Extract<keyof T, string>>(key: K, updater: Setter<StateType<T[K]>>): void;
+  /**
+   * 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
+   */
   subscribe: (subscriber: AppSubscriber<T>) => () => void;
+  /**
+   * Register Middleware
+   *
+   * Adds middleware instances to each of the connected
+   * `State` instances
+   */
   registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]): void;
   private emit;
 }
 /**
- * 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
+ * }));
  * ```
  */
 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":";;;;;;;AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;EAKhC,GAAA,WAAc,OAAA,OAAc,CAAA,UAAA,CAAY,GAAA,EAAK,CAAA,GAAC,CAAA,CAAA,CAAA;EAI9C,SAAA,GAAa,UAAA,EAAY,aAAA,CAAc,CAAA;EAsBvC,kBAAA,CAAA,GAAsB,WAAA,EAAa,UAAA,CAAW,UAAA,CAAW,CAAA;EAAA,QAMxD,IAAA;AAAA;;;;;;;;;;;;;;;;;;AAsCV;;;;;;;;;;;;;;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,45 +1,90 @@
+import { API } from "./API.mjs";
 import { EventEmitter } from "@figliolia/event-emitter";
 //#region src/Galena.ts
 /**
-* 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
+* }));
 * ```
 */
-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
+	*
+	* Returns a connected State instance by key
+	*/
 	get(key) {
 		return this.state[key];
 	}
+	/**
+	* Set
+	*
+	* Sets a connected State instance's state by key
+	*/
+	set(key, value) {
+		return this.get(key).set(value);
+	}
+	/**
+	* Update
+	*
+	* Invokes a connected State instance's update method key
+	*/
+	update(key, updater) {
+		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
+	*/
 	subscribe = (subscriber) => {
 		const ID = this.Emitter.on("change", subscriber);
 		const unsubscribers = [];
@@ -56,6 +101,12 @@ var Galena = class {
 			while (unsubscribers.length) unsubscribers.pop?.()?.();
 		};
 	};
+	/**
+	* Register Middleware
+	*
+	* Adds middleware instances to each of the connected
+	* `State` instances
+	*/
 	registerMiddleware(...middlewares) {
 		for (const key in this.state) this.state[key]?.registerMiddleware?.(...middlewares);
 	}
@@ -64,34 +115,41 @@ var Galena = class {
 	}
 };
 /**
-* 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
+* }));
 * ```
 */
 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 { AppSubscriber, GalenaSnapshot, StateTypes } from \"./types\";\n\n/**\n * Galena\n *\n * Galena is 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 * This is dissimilar to redux-like models where downstream reconciliations\n * will propagate everwhere a given store is read from. In galena, downstream\n * reconciliations occur only for consumers of the slice of state that\n * changed - making it safer to use with more frequent state changes.\n *\n * ```typescript\n * import { Galena } from \"@figliolia/galena\";\n *\n * const AppState = new Galena({\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 unsubscribe = AppState.subscribe(({ updated }) => {\n *   // do something with the `State` instance that updated\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  public get<K extends Extract<keyof T, string>>(key: K) {\n    return this.state[key];\n  }\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  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 * Create Galena\n *\n * Galena is 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 * This is dissimilar to redux-like models where downstream reconciliations\n * will propagate everwhere a given store is read from. In galena, downstream\n * reconciliations occur only for consumers of the slice of state that\n * changed - making it safer to use with more frequent state changes.\n *\n * ```typescript\n * import { createGalena } from \"@figliolia/galena\";\n *\n * const AppState = createGalena({\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 unsubscribe = AppState.subscribe(({ updated }) => {\n *   // do something with the `State` instance that updated\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAa,SAAb,MAA0D;CACxD,UAAkB,IAAI,cAA6C;CACnE,YACE,OACA,GAAG,YACH;AAFgB,OAAA,QAAA;AAGhB,OAAK,mBAAmB,GAAG,WAAW;;CAGxC,IAA+C,KAAQ;AACrD,SAAO,KAAK,MAAM;;CAGpB,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;;;CAK/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCtC,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());
 		}
 	}
 };

package/dist/Profiler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Profiler.mjs","names":[],"sources":["../src/Profiler.ts"],"sourcesContent":["import { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\n\n/**\n * Profiler\n *\n * A logger for state transitions exceeding a given\n * millisecond threshold\n *\n * ```typescript\n * const AppState = new Galena({}, new Profiler());\n * // or\n * AppState.registerMiddlerware(new Profiler());\n * // or\n * const MyState = new State(4, new Profiler());\n * // or\n * MyState.registerMiddleware(new Profiler());\n * ```\n */\nexport class Profiler<T = any> extends Middleware<T> {\n  private previousState: T | null = null;\n  private startTime: null | number = null;\n  constructor(public readonly threshold = 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: State<T>) {\n    if (this.startTime === null) {\n      return;\n    }\n    const diff = performance.now() - this.startTime;\n    if (diff >= this.threshold) {\n      console.warn(\n        `A slow state transition of ${diff.toFixed(1)}ms was detected when transitioning the following piece of state`,\n      );\n      console.log(\n        \"   %cPrevious State\",\n        \"color: #26ad65; font-weight: bold\",\n        this.previousState,\n      );\n      console.log(\n        \"   %cCurrent State    \",\n        \"color: rgb(17, 118, 249); font-weight: bold\",\n        state.getSnapshot(),\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,WAAb,cAAuC,WAAc;CACnD,gBAAkC;CAClC,YAAmC;CACnC,YAAY,YAA4B,IAAI;AAC1C,SAAO;AADmB,OAAA,YAAA;;CAI5B,eAA+B,OAAiB;AAC9C,OAAK,YAAY,YAAY,KAAK;AAClC,OAAK,gBAAgB,MAAM,aAAa;;CAG1C,SAAyB,OAAiB;AACxC,MAAI,KAAK,cAAc,KACrB;EAEF,MAAM,OAAO,YAAY,KAAK,GAAG,KAAK;AACtC,MAAI,QAAQ,KAAK,WAAW;AAC1B,WAAQ,KACN,8BAA8B,KAAK,QAAQ,EAAE,CAAC,iEAC/C;AACD,WAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,WAAQ,IACN,0BACA,+CACA,MAAM,aAAa,CACpB"}
+{"version":3,"file":"Profiler.mjs","names":[],"sources":["../src/Profiler.ts"],"sourcesContent":["import { Middleware } from \"./Middleware\";\nimport type { State } from \"./State\";\n\n/**\n * Profiler\n *\n * A logger for state transitions exceeding a given\n * millisecond threshold\n *\n * ```typescript\n * const AppState = new Galena({}, new Profiler());\n * // or\n * AppState.registerMiddlerware(new Profiler());\n * // or\n * const MyState = new State(4, new Profiler());\n * // or\n * MyState.registerMiddleware(new Profiler());\n * ```\n */\nexport class Profiler<T = any> extends Middleware<T> {\n  private previousState: T | null = null;\n  private startTime: null | number = null;\n  constructor(public readonly threshold = 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: State<T>) {\n    if (this.startTime === null) {\n      return;\n    }\n    const diff = performance.now() - this.startTime;\n    if (diff >= this.threshold) {\n      console.warn(\n        `A slow state transition of ${diff.toFixed(1)}ms was detected when transitioning the following piece of state`,\n      );\n      console.log(\n        \"   %cPrevious State\",\n        \"color: #26ad65; font-weight: bold\",\n        this.previousState,\n      );\n      console.log(\n        \"   %cCurrent State    \",\n        \"color: rgb(17, 118, 249); font-weight: bold\",\n        state.getState(),\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,WAAb,cAAuC,WAAc;CACnD,gBAAkC;CAClC,YAAmC;CACnC,YAAY,YAA4B,IAAI;AAC1C,SAAO;AADmB,OAAA,YAAA;;CAI5B,eAA+B,OAAiB;AAC9C,OAAK,YAAY,YAAY,KAAK;AAClC,OAAK,gBAAgB,MAAM,UAAU;;CAGvC,SAAyB,OAAiB;AACxC,MAAI,KAAK,cAAc,KACrB;EAEF,MAAM,OAAO,YAAY,KAAK,GAAG,KAAK;AACtC,MAAI,QAAQ,KAAK,WAAW;AAC1B,WAAQ,KACN,8BAA8B,KAAK,QAAQ,EAAE,CAAC,iEAC/C;AACD,WAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,WAAQ,IACN,0BACA,+CACA,MAAM,UAAU,CACjB"}

package/dist/State.cjs

@@ -1,17 +1,18 @@
+const require_API = require("./API.cjs");
 let _figliolia_event_emitter = require("@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 @@ let _figliolia_event_emitter = require("@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 require_API.API {
 	state;
-	middleware = [];
 	Emitter = new _figliolia_event_emitter.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) {