@figliolia/galena 2.3.5 → 3.0.0

package/dist/Logger.d.mts

@@ -0,0 +1,35 @@
+import { Middleware } from "./Middleware.mjs";
+import { State } from "./State.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;

package/dist/Middleware.d.cts

@@ -0,0 +1,65 @@
+import { State } from "./State.cjs";
+
+//#region src/Middleware.d.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());
+ * ```
+ */
+declare class Middleware<T = any> {
+  /**
+   * On Before Update
+   *
+   * Executes prior to a `State` instance being updated.
+   * Receives the state prior to its update as a parameter
+   */
+  onBeforeUpdate(_state: State<T>): void;
+  /**
+   * On Update
+   *
+   * Executes after a `State` instance has been update.
+   * Receives the most recent state as a parameter
+   */
+  onUpdate(_state: State<T>): void;
+}
+//#endregion
+export { Middleware };
+//# sourceMappingURL=Middleware.d.cts.map

package/dist/Middleware.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Middleware.d.cts","names":[],"sources":["../src/Middleware.ts"],"mappings":";;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,UAAA;;;;;;;EAOJ,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,CAAA;;;;;;;EAQ7B,QAAA,CAAS,MAAA,EAAQ,KAAA,CAAM,CAAA;AAAA"}

package/dist/Middleware.d.mts

@@ -0,0 +1,65 @@
+import { State } from "./State.mjs";
+
+//#region src/Middleware.d.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());
+ * ```
+ */
+declare class Middleware<T = any> {
+  /**
+   * On Before Update
+   *
+   * Executes prior to a `State` instance being updated.
+   * Receives the state prior to its update as a parameter
+   */
+  onBeforeUpdate(_state: State<T>): void;
+  /**
+   * On Update
+   *
+   * Executes after a `State` instance has been update.
+   * Receives the most recent state as a parameter
+   */
+  onUpdate(_state: State<T>): void;
+}
+//#endregion
+export { Middleware };
+//# sourceMappingURL=Middleware.d.mts.map

package/dist/Middleware.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Middleware.d.mts","names":[],"sources":["../src/Middleware.ts"],"mappings":";;;;;AA6CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,UAAA;;;;;;;EAOJ,cAAA,CAAe,MAAA,EAAQ,KAAA,CAAM,CAAA;;;;;;;EAQ7B,QAAA,CAAS,MAAA,EAAQ,KAAA,CAAM,CAAA;AAAA"}

package/dist/Middleware.mjs

@@ -0,0 +1,64 @@
+//#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
+export { Middleware };
+
+//# sourceMappingURL=Middleware.mjs.map

package/dist/Middleware.mjs.map

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

package/dist/Profiler.cjs

@@ -0,0 +1,41 @@
+const require_Middleware = require("./Middleware.cjs");
+//#region src/Profiler.ts
+/**
+* Profiler
+*
+* A logger for state transitions exceeding a given
+* millisecond threshold
+*
+* ```typescript
+* const AppState = new Galena({}, new Profiler());
+* // or
+* AppState.registerMiddlerware(new Profiler());
+* // or
+* const MyState = new State(4, new Profiler());
+* // or
+* MyState.registerMiddleware(new Profiler());
+* ```
+*/
+var Profiler = class extends require_Middleware.Middleware {
+	previousState = null;
+	startTime = null;
+	constructor(threshold = 16) {
+		super();
+		this.threshold = threshold;
+	}
+	onBeforeUpdate(state) {
+		this.startTime = performance.now();
+		this.previousState = state.getSnapshot();
+	}
+	onUpdate(state) {
+		if (this.startTime === null) return;
+		const diff = performance.now() - this.startTime;
+		if (diff >= this.threshold) {
+			console.warn(`A slow state transition of ${diff}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());
+		}
+	}
+};
+//#endregion
+exports.Profiler = Profiler;

package/dist/Profiler.d.cts

@@ -0,0 +1,31 @@
+import { Middleware } from "./Middleware.cjs";
+import { State } from "./State.cjs";
+
+//#region src/Profiler.d.ts
+/**
+ * Profiler
+ *
+ * A logger for state transitions exceeding a given
+ * millisecond threshold
+ *
+ * ```typescript
+ * const AppState = new Galena({}, new Profiler());
+ * // or
+ * AppState.registerMiddlerware(new Profiler());
+ * // or
+ * const MyState = new State(4, new Profiler());
+ * // or
+ * MyState.registerMiddleware(new Profiler());
+ * ```
+ */
+declare class Profiler<T = any> extends Middleware<T> {
+  readonly threshold: number;
+  private previousState;
+  private startTime;
+  constructor(threshold?: number);
+  onBeforeUpdate(state: State<T>): void;
+  onUpdate(state: State<T>): void;
+}
+//#endregion
+export { Profiler };
+//# sourceMappingURL=Profiler.d.cts.map

package/dist/Profiler.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Profiler.d.cts","names":[],"sources":["../src/Profiler.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;;;cAAa,QAAA,kBAA0B,UAAA,CAAW,CAAA;EAAA,SAGpB,SAAA;EAAA,QAFpB,aAAA;EAAA,QACA,SAAA;cACoB,SAAA;EAIZ,cAAA,CAAe,KAAA,EAAO,KAAA,CAAM,CAAA;EAK5B,QAAA,CAAS,KAAA,EAAO,KAAA,CAAM,CAAA;AAAA"}

package/dist/Profiler.d.mts

@@ -0,0 +1,31 @@
+import { Middleware } from "./Middleware.mjs";
+import { State } from "./State.mjs";
+
+//#region src/Profiler.d.ts
+/**
+ * Profiler
+ *
+ * A logger for state transitions exceeding a given
+ * millisecond threshold
+ *
+ * ```typescript
+ * const AppState = new Galena({}, new Profiler());
+ * // or
+ * AppState.registerMiddlerware(new Profiler());
+ * // or
+ * const MyState = new State(4, new Profiler());
+ * // or
+ * MyState.registerMiddleware(new Profiler());
+ * ```
+ */
+declare class Profiler<T = any> extends Middleware<T> {
+  readonly threshold: number;
+  private previousState;
+  private startTime;
+  constructor(threshold?: number);
+  onBeforeUpdate(state: State<T>): void;
+  onUpdate(state: State<T>): void;
+}
+//#endregion
+export { Profiler };
+//# sourceMappingURL=Profiler.d.mts.map

package/dist/Profiler.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Profiler.d.mts","names":[],"sources":["../src/Profiler.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;;;cAAa,QAAA,kBAA0B,UAAA,CAAW,CAAA;EAAA,SAGpB,SAAA;EAAA,QAFpB,aAAA;EAAA,QACA,SAAA;cACoB,SAAA;EAIZ,cAAA,CAAe,KAAA,EAAO,KAAA,CAAM,CAAA;EAK5B,QAAA,CAAS,KAAA,EAAO,KAAA,CAAM,CAAA;AAAA"}

package/dist/Profiler.mjs

@@ -0,0 +1,43 @@
+import { Middleware } from "./Middleware.mjs";
+//#region src/Profiler.ts
+/**
+* Profiler
+*
+* A logger for state transitions exceeding a given
+* millisecond threshold
+*
+* ```typescript
+* const AppState = new Galena({}, new Profiler());
+* // or
+* AppState.registerMiddlerware(new Profiler());
+* // or
+* const MyState = new State(4, new Profiler());
+* // or
+* MyState.registerMiddleware(new Profiler());
+* ```
+*/
+var Profiler = class extends Middleware {
+	previousState = null;
+	startTime = null;
+	constructor(threshold = 16) {
+		super();
+		this.threshold = threshold;
+	}
+	onBeforeUpdate(state) {
+		this.startTime = performance.now();
+		this.previousState = state.getSnapshot();
+	}
+	onUpdate(state) {
+		if (this.startTime === null) return;
+		const diff = performance.now() - this.startTime;
+		if (diff >= this.threshold) {
+			console.warn(`A slow state transition of ${diff}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());
+		}
+	}
+};
+//#endregion
+export { Profiler };
+
+//# sourceMappingURL=Profiler.mjs.map

package/dist/Profiler.mjs.map

@@ -0,0 +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}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,iEACpC;AACD,WAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,WAAQ,IACN,0BACA,+CACA,MAAM,aAAa,CACpB"}

package/dist/State.cjs

@@ -0,0 +1,147 @@
+let _figliolia_event_emitter = require("@figliolia/event-emitter");
+//#region src/State.ts
+/**
+* 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
+*
+* ```typescript
+* import { State, createState, useState, 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());
+*
+* // 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
+*   );
+* }
+* ```
+*/
+var State = class {
+	state;
+	middleware = [];
+	Emitter = new _figliolia_event_emitter.EventEmitter();
+	constructor(initialState, ...middleware) {
+		this.initialState = initialState;
+		this.state = initialState;
+		this.registerMiddleware(...middleware);
+	}
+	/**
+	* Set
+	*
+	* Updates the current value of state notifying
+	* all interested parties
+	*/
+	set = this.withEmission((state) => state);
+	/**
+	* Update
+	*
+	* Updates the current value of state using a setter function
+	* receiving the previous state as a parameter. Notifies all
+	* interested parties
+	*/
+	update = this.withEmission((setter) => {
+		if (this.diffSetter(setter)) return setter;
+		return setter(this.state);
+	});
+	/**
+	* Reset
+	*
+	* Resets the current state back to the state which the instance
+	* was initialized with. Notifies all interested parties
+	*/
+	reset = this.withEmission(() => this.initialState);
+	/**
+	* Get Snapshot
+	*
+	* Returns the current state. Designed for compatibility with
+	* `useSyncExternalStore`
+	*/
+	getSnapshot = () => {
+		return this.state;
+	};
+	/**
+	* Subscribe
+	*
+	* Registers a callback to be executed each time state
+	* changes. Returns an `unsubscribe` function
+	*/
+	subscribe = (fn) => {
+		const ID = this.Emitter.on("change", fn);
+		return () => {
+			this.Emitter.off("change", ID);
+		};
+	};
+	/**
+	* Register Middleware
+	*
+	* Registers any number of `Middleware` instances on the
+	* current instance of `State`. Your middleware will begin
+	* executing at the next state transition
+	*/
+	registerMiddleware(...middleware) {
+		this.middleware.push(...middleware);
+	}
+	withEmission(fn) {
+		return (...args) => {
+			const result = fn(...args);
+			if (result instanceof Promise) {
+				result.then((resolved) => this.emit(resolved));
+				return;
+			}
+			return this.emit(result);
+		};
+	}
+	emit(nextState) {
+		this.invokeMiddleware("onBeforeUpdate");
+		this.state = nextState;
+		this.Emitter.emit("change", this.state);
+		this.invokeMiddleware("onUpdate");
+	}
+	diffSetter(setter) {
+		return typeof setter !== "function";
+	}
+	invokeMiddleware(fn) {
+		for (const middleware of this.middleware) middleware[fn](this);
+	}
+};
+/**
+* Create State
+*
+* Returns the unit of reactivity for Galena. `State`'s can act
+* as isolated instances or be part of your global app
+* state (via `Galena` instances);
+*
+* ```typescript
+* import { createState, Profiler } from "@figliolia/galena";
+*
+* const myState = createState("<any value>", ...middleware);
+*
+* myState.set("<new-value>");
+* myState.update(previousValue => "<new-value>");
+* myState.subscribe(nextValue => {});
+* myState.registerMiddleware(new Profiler());
+* ```
+*/
+function createState(...args) {
+	return new State(...args);
+}
+//#endregion
+exports.State = State;
+exports.createState = createState;