@figliolia/galena 2.3.5 → 3.0.1

package/dist/Galena.cjs

@@ -0,0 +1,102 @@
+let _figliolia_event_emitter = require("@figliolia/event-emitter");
+//#region src/Galena.ts
+/**
+* Galena
+*
+* Galena is 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({
+*   // your reactive instances
+* }, ...middleware);
+*
+* // to retreive and work with an individual unit
+* const myUnit = AppState.get("<key>"); // Returns State<T>
+*
+* // to run a callback anytime a unit of state changes
+* const unsubscribe = AppState.subscribe(({ updated }) => {
+*   // do something with the `State` instance that updated
+* });
+* ```
+*/
+var Galena = class {
+	Emitter = new _figliolia_event_emitter.EventEmitter();
+	constructor(state, ...middleware) {
+		this.state = state;
+		this.registerMiddleware(...middleware);
+	}
+	get(key) {
+		return this.state[key];
+	}
+	subscribe = (subscriber) => {
+		const ID = this.Emitter.on("change", subscriber);
+		const unsubscribers = [];
+		for (const key in this.state) {
+			const instance = this.state[key];
+			if (!instance) continue;
+			unsubscribers.push(instance.subscribe(() => this.emit({
+				state: this.state,
+				updated: instance
+			})));
+		}
+		return () => {
+			this.Emitter.off("change", ID);
+			while (unsubscribers.length) unsubscribers.pop?.()?.();
+		};
+	};
+	registerMiddleware(...middlewares) {
+		for (const key in this.state) this.state[key]?.registerMiddleware?.(...middlewares);
+	}
+	emit(event) {
+		this.Emitter.emit("change", event);
+	}
+};
+/**
+* Create Galena
+*
+* Galena is 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";
+*
+* const AppState = createGalena({
+*   // your reactive instances
+* }, ...middleware);
+*
+* // to retreive and work with an individual unit
+* const myUnit = AppState.get("<key>"); // Returns State<T>
+*
+* // to run a callback anytime a unit of state changes
+* const unsubscribe = AppState.subscribe(({ updated }) => {
+*   // do something with the `State` instance that updated
+* });
+* ```
+*/
+const createGalena = (...args) => {
+	return new Galena(...args);
+};
+//#endregion
+exports.Galena = Galena;
+exports.createGalena = createGalena;

package/dist/Galena.d.cts

@@ -0,0 +1,80 @@
+import { AppSubscriber, StateTypes } from "./types.cjs";
+import { State } from "./State.cjs";
+import { Middleware } from "./Middleware.cjs";
+
+//#region src/Galena.d.ts
+/**
+ * Galena
+ *
+ * Galena is 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({
+ *   // your reactive instances
+ * }, ...middleware);
+ *
+ * // to retreive and work with an individual unit
+ * const myUnit = AppState.get("<key>"); // Returns State<T>
+ *
+ * // to run a callback anytime a unit of state changes
+ * const unsubscribe = AppState.subscribe(({ updated }) => {
+ *   // do something with the `State` instance that updated
+ * });
+ * ```
+ */
+declare class Galena<T extends Record<string, State<any>>> {
+  readonly state: T;
+  private Emitter;
+  constructor(state: T, ...middleware: Middleware<StateTypes<T>>[]);
+  get<K extends Extract<keyof T, string>>(key: K): T[K];
+  subscribe: (subscriber: AppSubscriber<T>) => () => void;
+  registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]): void;
+  private emit;
+}
+/**
+ * Create Galena
+ *
+ * Galena is 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";
+ *
+ * const AppState = createGalena({
+ *   // your reactive instances
+ * }, ...middleware);
+ *
+ * // to retreive and work with an individual unit
+ * const myUnit = AppState.get("<key>"); // Returns State<T>
+ *
+ * // to run a callback anytime a unit of state changes
+ * const unsubscribe = AppState.subscribe(({ updated }) => {
+ *   // do something with the `State` instance that updated
+ * });
+ * ```
+ */
+declare const createGalena: <T extends Record<string, State<any>>>(...args: ConstructorParameters<typeof Galena<T>>) => Galena<T>;
+//#endregion
+export { Galena, createGalena };
+//# sourceMappingURL=Galena.d.cts.map

package/dist/Galena.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Galena.d.cts","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"}

package/dist/Galena.d.mts

@@ -0,0 +1,80 @@
+import { AppSubscriber, StateTypes } from "./types.mjs";
+import { State } from "./State.mjs";
+import { Middleware } from "./Middleware.mjs";
+
+//#region src/Galena.d.ts
+/**
+ * Galena
+ *
+ * Galena is 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({
+ *   // your reactive instances
+ * }, ...middleware);
+ *
+ * // to retreive and work with an individual unit
+ * const myUnit = AppState.get("<key>"); // Returns State<T>
+ *
+ * // to run a callback anytime a unit of state changes
+ * const unsubscribe = AppState.subscribe(({ updated }) => {
+ *   // do something with the `State` instance that updated
+ * });
+ * ```
+ */
+declare class Galena<T extends Record<string, State<any>>> {
+  readonly state: T;
+  private Emitter;
+  constructor(state: T, ...middleware: Middleware<StateTypes<T>>[]);
+  get<K extends Extract<keyof T, string>>(key: K): T[K];
+  subscribe: (subscriber: AppSubscriber<T>) => () => void;
+  registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]): void;
+  private emit;
+}
+/**
+ * Create Galena
+ *
+ * Galena is 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";
+ *
+ * const AppState = createGalena({
+ *   // your reactive instances
+ * }, ...middleware);
+ *
+ * // to retreive and work with an individual unit
+ * const myUnit = AppState.get("<key>"); // Returns State<T>
+ *
+ * // to run a callback anytime a unit of state changes
+ * const unsubscribe = AppState.subscribe(({ updated }) => {
+ *   // do something with the `State` instance that updated
+ * });
+ * ```
+ */
+declare const createGalena: <T extends Record<string, State<any>>>(...args: ConstructorParameters<typeof Galena<T>>) => Galena<T>;
+//#endregion
+export { Galena, createGalena };
+//# sourceMappingURL=Galena.d.mts.map

package/dist/Galena.d.mts.map

@@ -0,0 +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"}

package/dist/Galena.mjs

@@ -0,0 +1,103 @@
+import { EventEmitter } from "@figliolia/event-emitter";
+//#region src/Galena.ts
+/**
+* Galena
+*
+* Galena is 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({
+*   // your reactive instances
+* }, ...middleware);
+*
+* // to retreive and work with an individual unit
+* const myUnit = AppState.get("<key>"); // Returns State<T>
+*
+* // to run a callback anytime a unit of state changes
+* const unsubscribe = AppState.subscribe(({ updated }) => {
+*   // do something with the `State` instance that updated
+* });
+* ```
+*/
+var Galena = class {
+	Emitter = new EventEmitter();
+	constructor(state, ...middleware) {
+		this.state = state;
+		this.registerMiddleware(...middleware);
+	}
+	get(key) {
+		return this.state[key];
+	}
+	subscribe = (subscriber) => {
+		const ID = this.Emitter.on("change", subscriber);
+		const unsubscribers = [];
+		for (const key in this.state) {
+			const instance = this.state[key];
+			if (!instance) continue;
+			unsubscribers.push(instance.subscribe(() => this.emit({
+				state: this.state,
+				updated: instance
+			})));
+		}
+		return () => {
+			this.Emitter.off("change", ID);
+			while (unsubscribers.length) unsubscribers.pop?.()?.();
+		};
+	};
+	registerMiddleware(...middlewares) {
+		for (const key in this.state) this.state[key]?.registerMiddleware?.(...middlewares);
+	}
+	emit(event) {
+		this.Emitter.emit("change", event);
+	}
+};
+/**
+* Create Galena
+*
+* Galena is 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";
+*
+* const AppState = createGalena({
+*   // your reactive instances
+* }, ...middleware);
+*
+* // to retreive and work with an individual unit
+* const myUnit = AppState.get("<key>"); // Returns State<T>
+*
+* // to run a callback anytime a unit of state changes
+* const unsubscribe = AppState.subscribe(({ updated }) => {
+*   // do something with the `State` instance that updated
+* });
+* ```
+*/
+const createGalena = (...args) => {
+	return new Galena(...args);
+};
+//#endregion
+export { Galena, createGalena };
+
+//# sourceMappingURL=Galena.mjs.map

package/dist/Galena.mjs.map

@@ -0,0 +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"}

package/dist/Logger.cjs

@@ -0,0 +1,46 @@
+const require_Middleware = require("./Middleware.cjs");
+//#region src/Logger.ts
+/**
+* Logger
+*
+* A middleware for Redux-style logging! Each state transition
+* will log to the console the `State` instance that changed
+* along with a before and after snapshot of the current state:
+*
+* ```typescript
+* const AppState = new Galena({}, new Logger());
+* // or
+* AppState.registerMiddlerware(new Logger());
+* // or
+* const MyState = new State(4, new Logger());
+* // or
+* MyState.registerMiddleware(new Logger());
+* ```
+*/
+var Logger = class extends require_Middleware.Middleware {
+	previousState = null;
+	onBeforeUpdate(state) {
+		this.previousState = state.getSnapshot();
+	}
+	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());
+	}
+	/**
+	* Time
+	*
+	* Returns the time in which a given state transition completed
+	*/
+	get time() {
+		const date = /* @__PURE__ */ new Date();
+		const mHours = date.getHours();
+		const hours = mHours > 12 ? mHours - 12 : mHours;
+		const mins = date.getMinutes();
+		const minutes = mins.toString().length === 1 ? `0${mins}` : mins;
+		const secs = date.getSeconds();
+		return `${hours}:${minutes}:${secs.toString().length === 1 ? `0${secs}` : secs}:${date.getMilliseconds()}`;
+	}
+};
+//#endregion
+exports.Logger = Logger;

package/dist/Logger.d.cts

@@ -0,0 +1,35 @@
+import { State } from "./State.cjs";
+import { Middleware } from "./Middleware.cjs";
+
+//#region src/Logger.d.ts
+/**
+ * Logger
+ *
+ * A middleware for Redux-style logging! Each state transition
+ * will log to the console the `State` instance that changed
+ * along with a before and after snapshot of the current state:
+ *
+ * ```typescript
+ * const AppState = new Galena({}, new Logger());
+ * // or
+ * AppState.registerMiddlerware(new Logger());
+ * // or
+ * const MyState = new State(4, new Logger());
+ * // or
+ * MyState.registerMiddleware(new Logger());
+ * ```
+ */
+declare class Logger<T = any> extends Middleware {
+  private previousState;
+  onBeforeUpdate(state: State<T>): void;
+  onUpdate(state: State<T>): void;
+  /**
+   * Time
+   *
+   * Returns the time in which a given state transition completed
+   */
+  private get time();
+}
+//#endregion
+export { Logger };
+//# sourceMappingURL=Logger.d.cts.map

package/dist/Logger.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.cts","names":[],"sources":["../src/Logger.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;cAAa,MAAA,kBAAwB,UAAA;EAAA,QAC3B,aAAA;EAEC,cAAA,CAAe,KAAA,EAAO,KAAA,CAAM,CAAA;EAI5B,QAAA,CAAS,KAAA,EAAO,KAAA,CAAM,CAAA;EAAA;;;;;EAAA,YAwBnB,IAAA,CAAA;AAAA"}

package/dist/Logger.d.mts

@@ -0,0 +1,35 @@
+import { State } from "./State.mjs";
+import { Middleware } from "./Middleware.mjs";
+
+//#region src/Logger.d.ts
+/**
+ * Logger
+ *
+ * A middleware for Redux-style logging! Each state transition
+ * will log to the console the `State` instance that changed
+ * along with a before and after snapshot of the current state:
+ *
+ * ```typescript
+ * const AppState = new Galena({}, new Logger());
+ * // or
+ * AppState.registerMiddlerware(new Logger());
+ * // or
+ * const MyState = new State(4, new Logger());
+ * // or
+ * MyState.registerMiddleware(new Logger());
+ * ```
+ */
+declare class Logger<T = any> extends Middleware {
+  private previousState;
+  onBeforeUpdate(state: State<T>): void;
+  onUpdate(state: State<T>): void;
+  /**
+   * Time
+   *
+   * Returns the time in which a given state transition completed
+   */
+  private get time();
+}
+//#endregion
+export { Logger };
+//# sourceMappingURL=Logger.d.mts.map

package/dist/Logger.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.mts","names":[],"sources":["../src/Logger.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;cAAa,MAAA,kBAAwB,UAAA;EAAA,QAC3B,aAAA;EAEC,cAAA,CAAe,KAAA,EAAO,KAAA,CAAM,CAAA;EAI5B,QAAA,CAAS,KAAA,EAAO,KAAA,CAAM,CAAA;EAAA;;;;;EAAA,YAwBnB,IAAA,CAAA;AAAA"}

package/dist/Logger.mjs

@@ -0,0 +1,48 @@
+import { Middleware } from "./Middleware.mjs";
+//#region src/Logger.ts
+/**
+* Logger
+*
+* A middleware for Redux-style logging! Each state transition
+* will log to the console the `State` instance that changed
+* along with a before and after snapshot of the current state:
+*
+* ```typescript
+* const AppState = new Galena({}, new Logger());
+* // or
+* AppState.registerMiddlerware(new Logger());
+* // or
+* const MyState = new State(4, new Logger());
+* // or
+* MyState.registerMiddleware(new Logger());
+* ```
+*/
+var Logger = class extends Middleware {
+	previousState = null;
+	onBeforeUpdate(state) {
+		this.previousState = state.getSnapshot();
+	}
+	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());
+	}
+	/**
+	* Time
+	*
+	* Returns the time in which a given state transition completed
+	*/
+	get time() {
+		const date = /* @__PURE__ */ new Date();
+		const mHours = date.getHours();
+		const hours = mHours > 12 ? mHours - 12 : mHours;
+		const mins = date.getMinutes();
+		const minutes = mins.toString().length === 1 ? `0${mins}` : mins;
+		const secs = date.getSeconds();
+		return `${hours}:${minutes}:${secs.toString().length === 1 ? `0${secs}` : secs}:${date.getMilliseconds()}`;
+	}
+};
+//#endregion
+export { Logger };
+
+//# sourceMappingURL=Logger.mjs.map

package/dist/Logger.mjs.map

@@ -0,0 +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"}

package/dist/Middleware.cjs

@@ -0,0 +1,62 @@
+//#region src/Middleware.ts
+/**
+* Middleware
+*
+* Galena's middleware API is designed to provide hooks
+* for state changes that you can tap into to run your
+* own logic.
+*
+* Middleware is great for logging, analytics, and profiling:
+*
+* ```typescript
+* export class Profiler<T = any> extends Middleware<T> {
+*   private previousState: T | null = null;
+*   private startTime: null | number = null;
+*   constructor(public readonly threshold: number = 16) {
+*     super();
+*   }
+*
+*   public override onBeforeUpdate(state: State<T>) {
+*     this.startTime = performance.now();
+*     this.previousState = state.getSnapshot();
+*   }
+*
+*   public override onUpdate(state: T) {
+*     const diff = performance.now() - this.startTime;
+*     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());
+*     }
+*   }
+* }
+* ```
+*
+* To register your middleware, simply add it when constructing
+* a `State` or `Galena` instance.
+*
+* ```typescript
+* import { State } from "@figliolia/galena";
+* import { Profiler } from './myProfiler';
+*
+* const myState = new State(5, new Profiler());
+* ```
+*/
+var Middleware = class {
+	/**
+	* On Before Update
+	*
+	* Executes prior to a `State` instance being updated.
+	* Receives the state prior to its update as a parameter
+	*/
+	onBeforeUpdate(_state) {}
+	/**
+	* On Update
+	*
+	* Executes after a `State` instance has been update.
+	* Receives the most recent state as a parameter
+	*/
+	onUpdate(_state) {}
+};
+//#endregion
+exports.Middleware = Middleware;