@figliolia/galena 2.3.5 → 3.0.0

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 { Middleware } from "./Middleware.cjs";
+import { AppSubscriber, StateTypes } from "./types.cjs";
+import { State } from "./State.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 { Middleware } from "./Middleware.mjs";
+import { AppSubscriber, StateTypes } from "./types.mjs";
+import { State } from "./State.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/GalenaProvider.cjs

@@ -0,0 +1,50 @@
+require("./Galena.cjs");
+let react = require("react");
+//#region src/GalenaProvider.tsx
+/**
+* Create Galena Provider
+*
+* For dependency injection with Galena, you can use this
+* function to produce a Context provider and a corresponding
+* `useGalena` hook
+*
+* ```typescript
+* import { Galena, createGalenaProvider } from "@figliolia/galena";
+*
+* const galena = new Galena({
+*   // state tree
+* }, ...middleware);
+*
+* const { GalenaProvider, useGalena } = createGalenaProvider(galena);
+* ```
+*
+* By wrapping your application in the `GalenaProvider` returned, you
+* can access your instance anywhere in your react code by calling
+* `useGalena()`
+*/
+function createGalenaProvider(galena) {
+	const GalenaContext = (0, react.createContext)(galena);
+	/**
+	* Galena Provider
+	*
+	* A context provider for your `Galena` instance to work with
+	* React dependency injection
+	*/
+	function GalenaProvider({ children }) {
+		return <GalenaContext.Provider value={galena}>{children}</GalenaContext.Provider>;
+	}
+	/**
+	* Use Galena
+	*
+	* Returns the instance of Galena provided by the `GalenaProvider`
+	*/
+	function useGalena() {
+		return (0, react.useContext)(GalenaContext);
+	}
+	return {
+		GalenaProvider,
+		useGalena
+	};
+}
+//#endregion
+exports.createGalenaProvider = createGalenaProvider;

package/dist/GalenaProvider.d.cts

@@ -0,0 +1,35 @@
+import { Galena } from "./Galena.cjs";
+import * as react from "react";
+import { PropsWithChildren } from "react";
+
+//#region src/GalenaProvider.d.ts
+/**
+ * Create Galena Provider
+ *
+ * For dependency injection with Galena, you can use this
+ * function to produce a Context provider and a corresponding
+ * `useGalena` hook
+ *
+ * ```typescript
+ * import { Galena, createGalenaProvider } from "@figliolia/galena";
+ *
+ * const galena = new Galena({
+ *   // state tree
+ * }, ...middleware);
+ *
+ * const { GalenaProvider, useGalena } = createGalenaProvider(galena);
+ * ```
+ *
+ * By wrapping your application in the `GalenaProvider` returned, you
+ * can access your instance anywhere in your react code by calling
+ * `useGalena()`
+ */
+declare function createGalenaProvider<T extends Galena<any>>(galena: T): {
+  GalenaProvider: ({
+    children
+  }: PropsWithChildren) => react.JSX.Element;
+  useGalena: () => T;
+};
+//#endregion
+export { createGalenaProvider };
+//# sourceMappingURL=GalenaProvider.d.cts.map

package/dist/GalenaProvider.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalenaProvider.d.cts","names":[],"sources":["../src/GalenaProvider.tsx"],"mappings":";;;;;;;;AAwBA;;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,WAA+B,MAAA,MAAA,CAAa,MAAA,EAAQ,CAAA;;;KAQ5B,iBAAA,KAAiB,KAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/GalenaProvider.d.mts

@@ -0,0 +1,35 @@
+import { Galena } from "./Galena.mjs";
+import * as react from "react";
+import { PropsWithChildren } from "react";
+
+//#region src/GalenaProvider.d.ts
+/**
+ * Create Galena Provider
+ *
+ * For dependency injection with Galena, you can use this
+ * function to produce a Context provider and a corresponding
+ * `useGalena` hook
+ *
+ * ```typescript
+ * import { Galena, createGalenaProvider } from "@figliolia/galena";
+ *
+ * const galena = new Galena({
+ *   // state tree
+ * }, ...middleware);
+ *
+ * const { GalenaProvider, useGalena } = createGalenaProvider(galena);
+ * ```
+ *
+ * By wrapping your application in the `GalenaProvider` returned, you
+ * can access your instance anywhere in your react code by calling
+ * `useGalena()`
+ */
+declare function createGalenaProvider<T extends Galena<any>>(galena: T): {
+  GalenaProvider: ({
+    children
+  }: PropsWithChildren) => react.JSX.Element;
+  useGalena: () => T;
+};
+//#endregion
+export { createGalenaProvider };
+//# sourceMappingURL=GalenaProvider.d.mts.map

package/dist/GalenaProvider.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalenaProvider.d.mts","names":[],"sources":["../src/GalenaProvider.tsx"],"mappings":";;;;;;;;AAwBA;;;;;;;;;;;;;;;;;;iBAAgB,oBAAA,WAA+B,MAAA,MAAA,CAAa,MAAA,EAAQ,CAAA;;;KAQ5B,iBAAA,KAAiB,KAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/GalenaProvider.mjs

@@ -0,0 +1,52 @@
+import "./Galena.mjs";
+import { createContext, useContext } from "react";
+//#region src/GalenaProvider.tsx
+/**
+* Create Galena Provider
+*
+* For dependency injection with Galena, you can use this
+* function to produce a Context provider and a corresponding
+* `useGalena` hook
+*
+* ```typescript
+* import { Galena, createGalenaProvider } from "@figliolia/galena";
+*
+* const galena = new Galena({
+*   // state tree
+* }, ...middleware);
+*
+* const { GalenaProvider, useGalena } = createGalenaProvider(galena);
+* ```
+*
+* By wrapping your application in the `GalenaProvider` returned, you
+* can access your instance anywhere in your react code by calling
+* `useGalena()`
+*/
+function createGalenaProvider(galena) {
+	const GalenaContext = createContext(galena);
+	/**
+	* Galena Provider
+	*
+	* A context provider for your `Galena` instance to work with
+	* React dependency injection
+	*/
+	function GalenaProvider({ children }) {
+		return <GalenaContext.Provider value={galena}>{children}</GalenaContext.Provider>;
+	}
+	/**
+	* Use Galena
+	*
+	* Returns the instance of Galena provided by the `GalenaProvider`
+	*/
+	function useGalena() {
+		return useContext(GalenaContext);
+	}
+	return {
+		GalenaProvider,
+		useGalena
+	};
+}
+//#endregion
+export { createGalenaProvider };
+
+//# sourceMappingURL=GalenaProvider.mjs.map

package/dist/GalenaProvider.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GalenaProvider.mjs","names":[],"sources":["../src/GalenaProvider.tsx"],"sourcesContent":["import { createContext, type PropsWithChildren, useContext } from \"react\";\nimport { type Galena } from \"./Galena\";\n\n/**\n * Create Galena Provider\n *\n * For dependency injection with Galena, you can use this\n * function to produce a Context provider and a corresponding\n * `useGalena` hook\n *\n * ```typescript\n * import { Galena, createGalenaProvider } from \"@figliolia/galena\";\n *\n * const galena = new Galena({\n *   // state tree\n * }, ...middleware);\n *\n * const { GalenaProvider, useGalena } = createGalenaProvider(galena);\n * ```\n *\n * By wrapping your application in the `GalenaProvider` returned, you\n * can access your instance anywhere in your react code by calling\n * `useGalena()`\n */\nexport function createGalenaProvider<T extends Galena<any>>(galena: T) {\n  const GalenaContext = createContext<T>(galena);\n  /**\n   * Galena Provider\n   *\n   * A context provider for your `Galena` instance to work with\n   * React dependency injection\n   */\n  function GalenaProvider({ children }: PropsWithChildren) {\n    return (\n      <GalenaContext.Provider value={galena}>{children}</GalenaContext.Provider>\n    );\n  }\n  /**\n   * Use Galena\n   *\n   * Returns the instance of Galena provided by the `GalenaProvider`\n   */\n  function useGalena() {\n    return useContext(GalenaContext);\n  }\n  return { GalenaProvider, useGalena };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,qBAA4C,QAAW;CACrE,MAAM,gBAAgB,cAAiB,OAAO;;;;;;;CAO9C,SAAS,eAAe,EAAE,YAA+B;AACvD,SACE,CAAC,cAAc,SAAS,OAAO,SAAS,SAAS,EAAE,cAAc;;;;;;;CAQrE,SAAS,YAAY;AACnB,SAAO,WAAW,cAAc;;AAElC,QAAO;EAAE;EAAgB;EAAW"}

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 { Middleware } from "./Middleware.cjs";
+import { State } from "./State.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"}