@figliolia/galena 2.3.5 → 3.0.1

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.toFixed(1)}ms was detected when transitioning the following piece of state`);
+			console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
+			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+		}
+	}
+};
+//#endregion
+exports.Profiler = Profiler;

package/dist/Profiler.d.cts

@@ -0,0 +1,31 @@
+import { State } from "./State.cjs";
+import { Middleware } from "./Middleware.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 { State } from "./State.mjs";
+import { Middleware } from "./Middleware.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.toFixed(1)}ms was detected when transitioning the following piece of state`);
+			console.log("   %cPrevious State", "color: #26ad65; font-weight: bold", this.previousState);
+			console.log("   %cCurrent State    ", "color: rgb(17, 118, 249); font-weight: bold", state.getSnapshot());
+		}
+	}
+};
+//#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.toFixed(1)}ms was detected when transitioning the following piece of state`,\n      );\n      console.log(\n        \"   %cPrevious State\",\n        \"color: #26ad65; font-weight: bold\",\n        this.previousState,\n      );\n      console.log(\n        \"   %cCurrent State    \",\n        \"color: rgb(17, 118, 249); font-weight: bold\",\n        state.getSnapshot(),\n      );\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAa,WAAb,cAAuC,WAAc;CACnD,gBAAkC;CAClC,YAAmC;CACnC,YAAY,YAA4B,IAAI;AAC1C,SAAO;AADmB,OAAA,YAAA;;CAI5B,eAA+B,OAAiB;AAC9C,OAAK,YAAY,YAAY,KAAK;AAClC,OAAK,gBAAgB,MAAM,aAAa;;CAG1C,SAAyB,OAAiB;AACxC,MAAI,KAAK,cAAc,KACrB;EAEF,MAAM,OAAO,YAAY,KAAK,GAAG,KAAK;AACtC,MAAI,QAAQ,KAAK,WAAW;AAC1B,WAAQ,KACN,8BAA8B,KAAK,QAAQ,EAAE,CAAC,iEAC/C;AACD,WAAQ,IACN,uBACA,qCACA,KAAK,cACN;AACD,WAAQ,IACN,0BACA,+CACA,MAAM,aAAa,CACpB"}

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;

package/dist/State.d.cts

@@ -0,0 +1,114 @@
+import { NonFunction, Setter, Subscriber } from "./types.cjs";
+import { Middleware } from "./Middleware.cjs";
+
+//#region src/State.d.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
+ *   );
+ * }
+ * ```
+ */
+declare class State<T> {
+  readonly initialState: NonFunction<T>;
+  private state;
+  readonly middleware: Middleware<T>[];
+  private readonly Emitter;
+  constructor(initialState: NonFunction<T>, ...middleware: Middleware<T>[]);
+  /**
+   * Set
+   *
+   * Updates the current value of state notifying
+   * all interested parties
+   */
+  readonly set: (state: NonFunction<T>) => void;
+  /**
+   * Update
+   *
+   * Updates the current value of state using a setter function
+   * receiving the previous state as a parameter. Notifies all
+   * interested parties
+   */
+  readonly update: (setter: Setter<T>) => void;
+  /**
+   * Reset
+   *
+   * Resets the current state back to the state which the instance
+   * was initialized with. Notifies all interested parties
+   */
+  readonly reset: () => void;
+  /**
+   * Get Snapshot
+   *
+   * Returns the current state. Designed for compatibility with
+   * `useSyncExternalStore`
+   */
+  readonly getSnapshot: () => NonFunction<T>;
+  /**
+   * Subscribe
+   *
+   * Registers a callback to be executed each time state
+   * changes. Returns an `unsubscribe` function
+   */
+  readonly subscribe: (fn: Subscriber<T>) => () => void;
+  /**
+   * 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: Middleware<T>[]): void;
+  private withEmission;
+  private emit;
+  protected diffSetter(setter: Setter<T>): setter is NonFunction<T>;
+  private invokeMiddleware;
+}
+/**
+ * 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());
+ * ```
+ */
+declare function createState<T>(...args: ConstructorParameters<typeof State<T>>): State<T>;
+//#endregion
+export { State, createState };
+//# sourceMappingURL=State.d.cts.map

package/dist/State.d.cts.map

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