@figliolia/galena 2.3.5 → 3.0.1

package/dist/State.d.mts

@@ -0,0 +1,114 @@
+import { NonFunction, Setter, Subscriber } from "./types.mjs";
+import { Middleware } from "./Middleware.mjs";
+
+//#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.mts.map

package/dist/State.d.mts.map

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

package/dist/State.mjs

@@ -0,0 +1,148 @@
+import { EventEmitter } from "@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 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
+export { State, createState };
+
+//# sourceMappingURL=State.mjs.map

package/dist/State.mjs.map

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

package/dist/index.cjs

@@ -0,0 +1,13 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Galena = require("./Galena.cjs");
+const require_Middleware = require("./Middleware.cjs");
+const require_Logger = require("./Logger.cjs");
+const require_Profiler = require("./Profiler.cjs");
+const require_State = require("./State.cjs");
+exports.Galena = require_Galena.Galena;
+exports.Logger = require_Logger.Logger;
+exports.Middleware = require_Middleware.Middleware;
+exports.Profiler = require_Profiler.Profiler;
+exports.State = require_State.State;
+exports.createGalena = require_Galena.createGalena;
+exports.createState = require_State.createState;

package/dist/index.d.cts

@@ -0,0 +1,7 @@
+import { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, 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 };

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, 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 };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { Galena, createGalena } from "./Galena.mjs";
+import { Middleware } from "./Middleware.mjs";
+import { Logger } from "./Logger.mjs";
+import { Profiler } from "./Profiler.mjs";
+import { State, createState } from "./State.mjs";
+export { Galena, Logger, Middleware, Profiler, State, createGalena, createState };

package/dist/types.d.cts

@@ -0,0 +1,16 @@
+import { State } from "./State.cjs";
+
+//#region src/types.d.ts
+type NonFunction<T> = T extends ((...args: any[]) => any) ? never : T;
+type PartialSupport<T> = T extends Record<string, any> ? Partial<T> : T;
+type Setter<T> = NonFunction<T> | ((prevState: NonFunction<T>) => NonFunction<T> | Promise<NonFunction<T>>);
+type Subscriber<T> = ((state: NonFunction<T>) => void) | (() => void);
+interface GalenaSnapshot<T extends Record<string, State<any>>, K extends Extract<keyof T, string> = Extract<keyof T, string>> {
+  updated: T[K];
+  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"]>;
+//#endregion
+export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+//# sourceMappingURL=types.d.cts.map

package/dist/types.d.cts.map

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

package/dist/types.d.mts

@@ -0,0 +1,16 @@
+import { State } from "./State.mjs";
+
+//#region src/types.d.ts
+type NonFunction<T> = T extends ((...args: any[]) => any) ? never : T;
+type PartialSupport<T> = T extends Record<string, any> ? Partial<T> : T;
+type Setter<T> = NonFunction<T> | ((prevState: NonFunction<T>) => NonFunction<T> | Promise<NonFunction<T>>);
+type Subscriber<T> = ((state: NonFunction<T>) => void) | (() => void);
+interface GalenaSnapshot<T extends Record<string, State<any>>, K extends Extract<keyof T, string> = Extract<keyof T, string>> {
+  updated: T[K];
+  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"]>;
+//#endregion
+export { AppSubscriber, GalenaSnapshot, NonFunction, PartialSupport, Setter, StateTypes, Subscriber };
+//# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

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

package/package.json

@@ -1,73 +1,52 @@
 {
   "name": "@figliolia/galena",
-  "version": "2.3.5",
-  "description": "A performant state management library supporting mutable state, batched updates, middleware and a rich development API",
-  "main": "dist/cjs/index.js",
-  "module": "dist/mjs/index.js",
-  "types": "dist/types/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/types/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src/*"
-  ],
-  "author": "Alex Figliolia",
-  "license": "MIT",
+  "version": "3.0.1",
+  "description": "A performant state management library supporting middleware and a rich developer API",
   "homepage": "https://github.com/alexfigliolia/galena#readme",
+  "license": "MIT",
+  "author": "Alex Figliolia",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/alexfigliolia/galena.git"
   },
-  "keywords": [
-    "state",
-    "state management",
-    "mutable",
-    "extendable",
-    "event",
-    "emitter",
-    "flux",
-    "island",
-    "batch",
-    "performance"
+  "files": [
+    "dist",
+    "src",
+    "media"
   ],
-  "scripts": {
-    "build": "ts-packager -e src",
-    "lint": "tsx ci/commands/Lint.ts",
-    "test": "tsx ci/commands/Test.ts"
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
   },
-  "dependencies": {
-    "@figliolia/event-emitter": "^1.1.5"
+  "publishConfig": {
+    "access": "public"
   },
-  "peerDependencies": {
-    "@figliolia/event-emitter": "^1.1.5"
+  "scripts": {
+    "build": "tsdown",
+    "lint": "oxlint --type-aware --type-check --report-unused-disable-directives --fix && oxfmt"
   },
   "devDependencies": {
-    "@figliolia/child-process": "^1.0.1",
-    "@figliolia/ts-packager": "^1.1.0",
-    "@types/node": "^20.11.19",
-    "@typescript-eslint/eslint-plugin": "^5.59.1",
-    "@typescript-eslint/parser": "^5.59.1",
-    "eslint": "^8.39.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-config-airbnb-typescript": "^17.0.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-import-resolver-typescript": "^3.6.1",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-json-format": "^2.0.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-simple-import-sort": "^10.0.0",
-    "eslint-plugin-unused-imports": "3",
-    "prettier": "^3.2.4",
-    "tsc-alias": "^1.8.8",
-    "tsx": "^4.7.1",
-    "typescript": "^5.3.3"
+    "@figliolia/event-emitter": "^1.2.0",
+    "@typescript-eslint/eslint-plugin": "^8.57.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "eslint": "^10.0.3",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.36.0",
+    "oxlint-tsgolint": "^0.17.0",
+    "tsdown": "^0.21.1",
+    "typescript": "^5.9.3"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "@figliolia/event-emitter": ">=1.2.0"
   }
-}
+}

package/src/Galena.ts

@@ -0,0 +1,120 @@
+import { EventEmitter } from "@figliolia/event-emitter";
+import type { Middleware } from "./Middleware";
+import type { State } from "./State";
+import type { AppSubscriber, GalenaSnapshot, StateTypes } from "./types";
+
+/**
+ * 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
+ * });
+ * ```
+ */
+export class Galena<T extends Record<string, State<any>>> {
+  private Emitter = new EventEmitter<{ change: GalenaSnapshot<T> }>();
+  constructor(
+    public readonly state: T,
+    ...middleware: Middleware<StateTypes<T>>[]
+  ) {
+    this.registerMiddleware(...middleware);
+  }
+
+  public get<K extends Extract<keyof T, string>>(key: K) {
+    return this.state[key];
+  }
+
+  public subscribe = (subscriber: AppSubscriber<T>) => {
+    const ID = this.Emitter.on("change", subscriber);
+    const unsubscribers: (() => void)[] = [];
+    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?.()?.();
+      }
+    };
+  };
+
+  public registerMiddleware(...middlewares: Middleware<StateTypes<T>>[]) {
+    for (const key in this.state) {
+      this.state[key]?.registerMiddleware?.(...middlewares);
+    }
+  }
+
+  private emit<K extends Extract<keyof T, string>>(
+    event: GalenaSnapshot<T, K>,
+  ) {
+    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
+ * });
+ * ```
+ */
+export const createGalena = <T extends Record<string, State<any>>>(
+  ...args: ConstructorParameters<typeof Galena<T>>
+) => {
+  return new Galena(...args);
+};

package/src/{Middlewares/Logger.ts → Logger.ts}

@@ -1,5 +1,5 @@
-import { State } from "Galena/State";
-import { Middleware } from "Middleware/Middleware";
+import { Middleware } from "./Middleware";
+import type { State } from "./State";
 
 /**
  * Logger
@@ -9,24 +9,26 @@ import { Middleware } from "Middleware/Middleware";
  * along with a before and after snapshot of the current state:
  *
  * ```typescript
- * const State = new Galena([new Logger()]);
- * // if using isolated state instances:
- * const MyState = new State(...args);
- * MyState.registerMiddleware(new Logger())
+ * const AppState = new Galena({}, new Logger());
+ * // or
+ * AppState.registerMiddlerware(new Logger());
+ * // or
+ * const MyState = new State(4, new Logger());
+ * // or
+ * MyState.registerMiddleware(new Logger());
  * ```
  */
-export class Logger extends Middleware {
-  private previousState: Record<string, any> | null = null;
+export class Logger<T = any> extends Middleware {
+  private previousState: T | null = null;
 
-  override onBeforeUpdate(state: State) {
-    this.previousState = State.clone(state.state);
+  override onBeforeUpdate(state: State<T>) {
+    this.previousState = state.getSnapshot();
   }
 
-  override onUpdate(state: State) {
+  override onUpdate(state: State<T>) {
     console.log(
       "%cMutation:",
       "color: rgb(187, 186, 186); font-weight: bold",
-      state.name,
       "@",
       this.time,
     );
@@ -38,9 +40,8 @@ export class Logger extends Middleware {
     console.log(
       "   %cNext State    ",
       "color: rgb(17, 118, 249); font-weight: bold",
-      state.getState(),
+      state.getSnapshot(),
     );
-    this.previousState = null;
   }
 
   /**