@figliolia/galena 3.0.1 → 3.0.3

package/dist/Galena.mjs

@@ -1,24 +1,21 @@
 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);
 *
@@ -26,8 +23,9 @@ import { EventEmitter } from "@figliolia/event-emitter";
 * const myUnit = AppState.get("<key>"); // 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
 * });
 * ```
 */
@@ -37,9 +35,38 @@ var Galena = class {
 		this.state = state;
 		this.registerMiddleware(...middleware);
 	}
+	/**
+	* 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 +83,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,24 +97,21 @@ 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);
 *
@@ -89,8 +119,9 @@ var Galena = class {
 * const myUnit = AppState.get("<key>"); // 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
 * });
 * ```
 */

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 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"}

package/dist/State.cjs

@@ -1,7 +1,7 @@
 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
@@ -10,7 +10,7 @@ let _figliolia_event_emitter = require("@figliolia/event-emitter");
 * There are three ways to create state instances
 *
 * ```typescript
-* import { State, createState, useState, Profiler } from "@figliolia/galena";
+* import { State, createState, Profiler } from "@figliolia/galena";
 * // for island states that can be shared between react components
 * const myState = new State("<any value>", ...middleware);
 * // or
@@ -20,17 +20,7 @@ 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
 * ```
 */
 var State = class {
@@ -122,21 +112,26 @@ 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 three ways to create state instances
 *
+* ```typescript
+* import { State, createState, Profiler } from "@figliolia/galena";
+* // for island states that can be shared between react components
+* 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
 * ```
 */
 function createState(...args) {

package/dist/State.d.cts

@@ -3,7 +3,7 @@ import { Middleware } from "./Middleware.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
@@ -12,7 +12,7 @@ import { Middleware } from "./Middleware.cjs";
  * There are three ways to create state instances
  *
  * ```typescript
- * import { State, createState, useState, Profiler } from "@figliolia/galena";
+ * import { State, createState, Profiler } from "@figliolia/galena";
  * // for island states that can be shared between react components
  * const myState = new State("<any value>", ...middleware);
  * // or
@@ -22,17 +22,7 @@ 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
  * ```
  */
 declare class State<T> {
@@ -91,21 +81,26 @@ 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 three ways to create state instances
  *
+ * ```typescript
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ * // for island states that can be shared between react components
+ * 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
  * ```
  */
 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":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;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;EANX;;;;;;EAAA,SAkBD,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAhBoB;;;;;;;EAAA,SAyBvB,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EArBM;;;;;;EAAA,SAkCZ,KAAA;EAbM;;;;;;EAAA,SAqBN,WAAA,QAAW,WAAA,CAAA,CAAA;EAUM;;;;;;EAAA,SAAjB,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EAkBpC;;;;;;;EAJD,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;;;;;;;;;;;;;;;;;;;;;;;;iBA8BM,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}

package/dist/State.d.mts

@@ -3,7 +3,7 @@ import { Middleware } from "./Middleware.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
@@ -12,7 +12,7 @@ import { Middleware } from "./Middleware.mjs";
  * There are three ways to create state instances
  *
  * ```typescript
- * import { State, createState, useState, Profiler } from "@figliolia/galena";
+ * import { State, createState, Profiler } from "@figliolia/galena";
  * // for island states that can be shared between react components
  * const myState = new State("<any value>", ...middleware);
  * // or
@@ -22,17 +22,7 @@ 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
  * ```
  */
 declare class State<T> {
@@ -91,21 +81,26 @@ 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 three ways to create state instances
  *
+ * ```typescript
+ * import { State, createState, Profiler } from "@figliolia/galena";
+ * // for island states that can be shared between react components
+ * 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
  * ```
  */
 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":";;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;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;EANX;;;;;;EAAA,SAkBD,GAAA,GAAG,KAAA,EAAA,WAAA,CAAA,CAAA;EAhBoB;;;;;;;EAAA,SAyBvB,MAAA,GAAM,MAAA,EAAA,MAAA,CAAA,CAAA;EArBM;;;;;;EAAA,SAkCZ,KAAA;EAbM;;;;;;EAAA,SAqBN,WAAA,QAAW,WAAA,CAAA,CAAA;EAUM;;;;;;EAAA,SAAjB,SAAA,GAAa,EAAA,EAAI,UAAA,CAAW,CAAA;EAkBpC;;;;;;;EAJD,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;;;;;;;;;;;;;;;;;;;;;;;;iBA8BM,WAAA,GAAA,CAAA,GACX,IAAA,EAAM,qBAAA,QAA6B,KAAA,CAAM,CAAA,KAAG,KAAA,CAAA,CAAA"}

package/dist/State.mjs

@@ -1,7 +1,7 @@
 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
@@ -10,7 +10,7 @@ import { EventEmitter } from "@figliolia/event-emitter";
 * There are three ways to create state instances
 *
 * ```typescript
-* import { State, createState, useState, Profiler } from "@figliolia/galena";
+* import { State, createState, Profiler } from "@figliolia/galena";
 * // for island states that can be shared between react components
 * const myState = new State("<any value>", ...middleware);
 * // or
@@ -20,17 +20,7 @@ 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
 * ```
 */
 var State = class {
@@ -122,21 +112,26 @@ 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 three ways to create state instances
 *
+* ```typescript
+* import { State, createState, Profiler } from "@figliolia/galena";
+* // for island states that can be shared between react components
+* 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
 * ```
 */
 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 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, 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 * myState.reset(); // reset back to it's original value\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 * ### 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 three ways to create state instances\n *\n * ```typescript\n * import { State, createState, 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 * myState.reset(); // reset back to it's original value\n * ```\n */\nexport function createState<T>(\n  ...args: ConstructorParameters<typeof State<T>>\n) {\n  return new State<T>(...args);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,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;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B1B,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, 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, 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, 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, Logger, Middleware, NonFunction, PartialSupport, Profiler, Setter, State, StateType, StateTypes, Subscriber, createGalena, createState };

package/dist/types.d.cts

@@ -10,7 +10,8 @@ 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["getSnapshot"]>;
 //#endregion
-export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+export { AppSubscriber, GalenaSnapshot, 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"}

package/dist/types.d.mts

@@ -10,7 +10,8 @@ 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["getSnapshot"]>;
 //#endregion
-export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+export { AppSubscriber, GalenaSnapshot, 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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@figliolia/galena",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "A performant state management library supporting middleware and a rich developer API",
   "homepage": "https://github.com/alexfigliolia/galena#readme",
   "license": "MIT",
@@ -44,9 +44,15 @@
     "oxlint": "^1.36.0",
     "oxlint-tsgolint": "^0.17.0",
     "tsdown": "^0.21.1",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "peerDependencies": {
     "@figliolia/event-emitter": ">=1.2.0"
-  }
+  },
+  "keywords": [
+    "state",
+    "state management",
+    "flux",
+    "react"
+  ]
 }