@figliolia/galena 2.3.4 → 3.0.0

package/dist/connect.mjs

@@ -0,0 +1,43 @@
+import { Component } from "react";
+//#region src/connect.tsx
+const connect = (state) => {
+	return (selection) => {
+		return (WrappedComponent) => {
+			return class GalenaComponent extends Component {
+				state;
+				listener = null;
+				constructor(props) {
+					super(props);
+					this.update = this.update.bind(this);
+					this.state = selection(state.getSnapshot(), this.props);
+				}
+				static displayName = `GalenaComponent(${(WrappedComponent.displayName ?? WrappedComponent.name) || "Component"})`;
+				componentDidMount() {
+					this.listener = state.subscribe((state) => this.update(state));
+				}
+				UNSAFE_componentWillReceiveProps(nextProps) {
+					if (nextProps !== this.props) this.update(state.getSnapshot(), nextProps);
+				}
+				shouldComponentUpdate(nextProps, nextState) {
+					return nextState !== this.state || nextProps !== this.props;
+				}
+				componentWillUnmount() {
+					if (this.listener) {
+						this.listener();
+						this.listener = null;
+					}
+				}
+				update(nextState, ownProps = this.props) {
+					this.setState(selection(nextState, ownProps));
+				}
+				render() {
+					return <WrappedComponent {...this.props} {...this.state} />;
+				}
+			};
+		};
+	};
+};
+//#endregion
+export { connect };
+
+//# sourceMappingURL=connect.mjs.map

package/dist/connect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.mjs","names":[],"sources":["../src/connect.tsx"],"sourcesContent":["import { Component, type ComponentType } from \"react\";\nimport type { State } from \"./State\";\nimport type { Subtract } from \"./types\";\n\nexport const connect = <StateInstance extends State<any>>(\n  state: StateInstance,\n) => {\n  type ScopedState = ReturnType<StateInstance[\"getSnapshot\"]>;\n  return <\n    SelectorFunction extends (\n      state: ScopedState,\n      ownProps: any,\n    ) => Record<string, any>,\n  >(\n    selection: SelectorFunction,\n  ) => {\n    type Selection = ReturnType<SelectorFunction>;\n    return <ComponentProps extends Selection>(\n      WrappedComponent: ComponentType<ComponentProps>,\n    ): ComponentType<Subtract<ComponentProps, Selection>> => {\n      type OwnProps = Subtract<ComponentProps, Selection>;\n      return class GalenaComponent extends Component<OwnProps, Selection> {\n        override state: any;\n        private listener: (() => void) | null = null;\n        constructor(props: OwnProps) {\n          super(props);\n          this.update = this.update.bind(this);\n          this.state = selection(state.getSnapshot(), this.props);\n        }\n\n        static displayName = `GalenaComponent(${\n          (WrappedComponent.displayName ?? WrappedComponent.name) || \"Component\"\n        })`;\n\n        public override componentDidMount() {\n          this.listener = state.subscribe(state => this.update(state));\n        }\n\n        public override UNSAFE_componentWillReceiveProps(nextProps: OwnProps) {\n          if (nextProps !== this.props) {\n            this.update(state.getSnapshot(), nextProps);\n          }\n        }\n\n        public override shouldComponentUpdate(\n          nextProps: OwnProps,\n          nextState: Selection,\n        ) {\n          return nextState !== this.state || nextProps !== this.props;\n        }\n\n        public override componentWillUnmount() {\n          if (this.listener) {\n            this.listener();\n            this.listener = null;\n          }\n        }\n\n        private update(nextState: ScopedState, ownProps = this.props) {\n          this.setState(selection(nextState, ownProps));\n        }\n\n        public override render() {\n          return <WrappedComponent {...this.props} {...this.state} />;\n        }\n      };\n    };\n  };\n};\n"],"mappings":";;AAIA,MAAa,WACX,UACG;AAEH,SAME,cACG;AAEH,UACE,qBACuD;AAEvD,UAAO,MAAM,wBAAwB,UAA+B;IAClE;IACA,WAAwC;IACxC,YAAY,OAAiB;AAC3B,WAAM,MAAM;AACZ,UAAK,SAAS,KAAK,OAAO,KAAK,KAAK;AACpC,UAAK,QAAQ,UAAU,MAAM,aAAa,EAAE,KAAK,MAAM;;IAGzD,OAAO,cAAc,oBAClB,iBAAiB,eAAe,iBAAiB,SAAS,YAC5D;IAED,oBAAoC;AAClC,UAAK,WAAW,MAAM,WAAU,UAAS,KAAK,OAAO,MAAM,CAAC;;IAG9D,iCAAiD,WAAqB;AACpE,SAAI,cAAc,KAAK,MACrB,MAAK,OAAO,MAAM,aAAa,EAAE,UAAU;;IAI/C,sBACE,WACA,WACA;AACA,YAAO,cAAc,KAAK,SAAS,cAAc,KAAK;;IAGxD,uBAAuC;AACrC,SAAI,KAAK,UAAU;AACjB,WAAK,UAAU;AACf,WAAK,WAAW;;;IAIpB,OAAe,WAAwB,WAAW,KAAK,OAAO;AAC5D,UAAK,SAAS,UAAU,WAAW,SAAS,CAAC;;IAG/C,SAAyB;AACvB,YAAO,CAAC,qBAAqB,KAAK,WAAW,KAAK"}

package/dist/createUseState.cjs

@@ -0,0 +1,47 @@
+const require_commonHooks = require("./commonHooks.cjs");
+//#region src/createUseState.ts
+/**
+* Create Use State
+*
+* A reuseable `State` consumer/creator for your react components.
+* This hook can accept an exising instance of `State` and return
+* a hook for deriving reactive state and updaters fn's for your components
+*
+* ```typescript
+* import { State, createUseState } from "@figliolia/galena";
+*
+* const myState = new State("<some-value>");
+*
+* export const useMyState = createUseState(myState);
+*
+* // In your components
+* export const MyComponent = () => {
+*   const [state, setState] = useMyState(
+*     // optional selector function
+*   );
+*
+*   return (
+*     // your jsx
+*   );
+* }
+* ```
+*
+* `useState` can accept an optional selector function for deriving
+* new values from a unit of state
+*
+* ```typescript
+* import { State, createUseState } from "@figliolia/galena";
+*
+* const myState = new State({ deeply: { nested: data: 4 } });
+* const useMyState = createUseState(myState);
+*
+* const eight = useMyState(myState, state => deeply.nested.data * 2);
+* ```
+*/
+const createUseState = (value) => {
+	return (selector = ((value) => value)) => {
+		return require_commonHooks.useStateHookAPI(value, require_commonHooks.useStableSelector(selector));
+	};
+};
+//#endregion
+exports.createUseState = createUseState;

package/dist/createUseState.d.cts

@@ -0,0 +1,46 @@
+import { NonFunction, Setter } from "./types.cjs";
+import { State } from "./State.cjs";
+
+//#region src/createUseState.d.ts
+/**
+ * Create Use State
+ *
+ * A reuseable `State` consumer/creator for your react components.
+ * This hook can accept an exising instance of `State` and return
+ * a hook for deriving reactive state and updaters fn's for your components
+ *
+ * ```typescript
+ * import { State, createUseState } from "@figliolia/galena";
+ *
+ * const myState = new State("<some-value>");
+ *
+ * export const useMyState = createUseState(myState);
+ *
+ * // In your components
+ * export const MyComponent = () => {
+ *   const [state, setState] = useMyState(
+ *     // optional selector function
+ *   );
+ *
+ *   return (
+ *     // your jsx
+ *   );
+ * }
+ * ```
+ *
+ * `useState` can accept an optional selector function for deriving
+ * new values from a unit of state
+ *
+ * ```typescript
+ * import { State, createUseState } from "@figliolia/galena";
+ *
+ * const myState = new State({ deeply: { nested: data: 4 } });
+ * const useMyState = createUseState(myState);
+ *
+ * const eight = useMyState(myState, state => deeply.nested.data * 2);
+ * ```
+ */
+declare const createUseState: <T>(value: State<T>) => <U = T>(selector?: (value: NonFunction<T>) => U) => readonly [U, (setter: Setter<T>) => void];
+//#endregion
+export { createUseState };
+//# sourceMappingURL=createUseState.d.cts.map

package/dist/createUseState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUseState.d.cts","names":[],"sources":["../src/createUseState.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,MAAqB,KAAA,EAAO,KAAA,CAAM,CAAA,WACjC,CAAA,EACV,QAAA,IACE,KAAA,EAAO,WAAA,CAAY,CAAA,MAChB,CAAA,eAAC,CAAA,GAAA,MAAA,EAAA,MAAA,CAAA,CAAA"}

package/dist/createUseState.d.mts

@@ -0,0 +1,46 @@
+import { NonFunction, Setter } from "./types.mjs";
+import { State } from "./State.mjs";
+
+//#region src/createUseState.d.ts
+/**
+ * Create Use State
+ *
+ * A reuseable `State` consumer/creator for your react components.
+ * This hook can accept an exising instance of `State` and return
+ * a hook for deriving reactive state and updaters fn's for your components
+ *
+ * ```typescript
+ * import { State, createUseState } from "@figliolia/galena";
+ *
+ * const myState = new State("<some-value>");
+ *
+ * export const useMyState = createUseState(myState);
+ *
+ * // In your components
+ * export const MyComponent = () => {
+ *   const [state, setState] = useMyState(
+ *     // optional selector function
+ *   );
+ *
+ *   return (
+ *     // your jsx
+ *   );
+ * }
+ * ```
+ *
+ * `useState` can accept an optional selector function for deriving
+ * new values from a unit of state
+ *
+ * ```typescript
+ * import { State, createUseState } from "@figliolia/galena";
+ *
+ * const myState = new State({ deeply: { nested: data: 4 } });
+ * const useMyState = createUseState(myState);
+ *
+ * const eight = useMyState(myState, state => deeply.nested.data * 2);
+ * ```
+ */
+declare const createUseState: <T>(value: State<T>) => <U = T>(selector?: (value: NonFunction<T>) => U) => readonly [U, (setter: Setter<T>) => void];
+//#endregion
+export { createUseState };
+//# sourceMappingURL=createUseState.d.mts.map

package/dist/createUseState.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUseState.d.mts","names":[],"sources":["../src/createUseState.ts"],"mappings":";;;;;;AA0CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,MAAqB,KAAA,EAAO,KAAA,CAAM,CAAA,WACjC,CAAA,EACV,QAAA,IACE,KAAA,EAAO,WAAA,CAAY,CAAA,MAChB,CAAA,eAAC,CAAA,GAAA,MAAA,EAAA,MAAA,CAAA,CAAA"}

package/dist/createUseState.mjs

@@ -0,0 +1,49 @@
+import { useStableSelector, useStateHookAPI } from "./commonHooks.mjs";
+//#region src/createUseState.ts
+/**
+* Create Use State
+*
+* A reuseable `State` consumer/creator for your react components.
+* This hook can accept an exising instance of `State` and return
+* a hook for deriving reactive state and updaters fn's for your components
+*
+* ```typescript
+* import { State, createUseState } from "@figliolia/galena";
+*
+* const myState = new State("<some-value>");
+*
+* export const useMyState = createUseState(myState);
+*
+* // In your components
+* export const MyComponent = () => {
+*   const [state, setState] = useMyState(
+*     // optional selector function
+*   );
+*
+*   return (
+*     // your jsx
+*   );
+* }
+* ```
+*
+* `useState` can accept an optional selector function for deriving
+* new values from a unit of state
+*
+* ```typescript
+* import { State, createUseState } from "@figliolia/galena";
+*
+* const myState = new State({ deeply: { nested: data: 4 } });
+* const useMyState = createUseState(myState);
+*
+* const eight = useMyState(myState, state => deeply.nested.data * 2);
+* ```
+*/
+const createUseState = (value) => {
+	return (selector = ((value) => value)) => {
+		return useStateHookAPI(value, useStableSelector(selector));
+	};
+};
+//#endregion
+export { createUseState };
+
+//# sourceMappingURL=createUseState.mjs.map

package/dist/createUseState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createUseState.mjs","names":[],"sources":["../src/createUseState.ts"],"sourcesContent":["import { useStableSelector, useStateHookAPI } from \"./commonHooks\";\nimport type { State } from \"./State\";\nimport type { NonFunction } from \"./types\";\n\n/**\n * Create Use State\n *\n * A reuseable `State` consumer/creator for your react components.\n * This hook can accept an exising instance of `State` and return\n * a hook for deriving reactive state and updaters fn's for your components\n *\n * ```typescript\n * import { State, createUseState } from \"@figliolia/galena\";\n *\n * const myState = new State(\"<some-value>\");\n *\n * export const useMyState = createUseState(myState);\n *\n * // In your components\n * export const MyComponent = () => {\n *   const [state, setState] = useMyState(\n *     // optional selector function\n *   );\n *\n *   return (\n *     // your jsx\n *   );\n * }\n * ```\n *\n * `useState` can accept an optional selector function for deriving\n * new values from a unit of state\n *\n * ```typescript\n * import { State, createUseState } from \"@figliolia/galena\";\n *\n * const myState = new State({ deeply: { nested: data: 4 } });\n * const useMyState = createUseState(myState);\n *\n * const eight = useMyState(myState, state => deeply.nested.data * 2);\n * ```\n */\nexport const createUseState = <T>(value: State<T>) => {\n  return <U = T>(\n    selector = ((value: NonFunction<T>) => value) as (\n      value: NonFunction<T>,\n    ) => U,\n  ) => {\n    const stableSelector = useStableSelector(selector);\n    return useStateHookAPI(value, stableSelector);\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,MAAa,kBAAqB,UAAoB;AACpD,SACE,aAAa,UAA0B,WAGpC;AAEH,SAAO,gBAAgB,OADA,kBAAkB,SAAS,CACL"}

package/dist/index.cjs

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_connect = require("./connect.cjs");
+const require_connect_multi = require("./connect-multi.cjs");
+const require_createUseState = require("./createUseState.cjs");
+const require_Galena = require("./Galena.cjs");
+const require_GalenaProvider = require("./GalenaProvider.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");
+const require_useState = require("./useState.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.connect = require_connect.connect;
+exports.connectMulti = require_connect_multi.connectMulti;
+exports.createGalena = require_Galena.createGalena;
+exports.createGalenaProvider = require_GalenaProvider.createGalenaProvider;
+exports.createState = require_State.createState;
+exports.createUseState = require_createUseState.createUseState;
+exports.useState = require_useState.useState;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { Middleware } from "./Middleware.cjs";
+import { AppSubscriber, DerivedArguments, DerivedSelector, GalenaSnapshot, NonFunction, PartialSupport, SetComplement, SetDifference, Setter, StateTypes, Subscriber, Subtract } from "./types.cjs";
+import { State, createState } from "./State.cjs";
+import { connect } from "./connect.cjs";
+import { ReactiveStates, connectMulti } from "./connect-multi.cjs";
+import { createUseState } from "./createUseState.cjs";
+import { Galena, createGalena } from "./Galena.cjs";
+import { createGalenaProvider } from "./GalenaProvider.cjs";
+import { Logger } from "./Logger.cjs";
+import { Profiler } from "./Profiler.cjs";
+import { useState } from "./useState.cjs";
+export { AppSubscriber, DerivedArguments, DerivedSelector, Galena, GalenaSnapshot, Logger, Middleware, NonFunction, PartialSupport, Profiler, ReactiveStates, SetComplement, SetDifference, Setter, State, StateTypes, Subscriber, Subtract, connect, connectMulti, createGalena, createGalenaProvider, createState, createUseState, useState };

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { Middleware } from "./Middleware.mjs";
+import { AppSubscriber, DerivedArguments, DerivedSelector, GalenaSnapshot, NonFunction, PartialSupport, SetComplement, SetDifference, Setter, StateTypes, Subscriber, Subtract } from "./types.mjs";
+import { State, createState } from "./State.mjs";
+import { connect } from "./connect.mjs";
+import { ReactiveStates, connectMulti } from "./connect-multi.mjs";
+import { createUseState } from "./createUseState.mjs";
+import { Galena, createGalena } from "./Galena.mjs";
+import { createGalenaProvider } from "./GalenaProvider.mjs";
+import { Logger } from "./Logger.mjs";
+import { Profiler } from "./Profiler.mjs";
+import { useState } from "./useState.mjs";
+export { AppSubscriber, DerivedArguments, DerivedSelector, Galena, GalenaSnapshot, Logger, Middleware, NonFunction, PartialSupport, Profiler, ReactiveStates, SetComplement, SetDifference, Setter, State, StateTypes, Subscriber, Subtract, connect, connectMulti, createGalena, createGalenaProvider, createState, createUseState, useState };

package/dist/index.mjs

@@ -0,0 +1,11 @@
+import { connect } from "./connect.mjs";
+import { connectMulti } from "./connect-multi.mjs";
+import { createUseState } from "./createUseState.mjs";
+import { Galena, createGalena } from "./Galena.mjs";
+import { createGalenaProvider } from "./GalenaProvider.mjs";
+import { Middleware } from "./Middleware.mjs";
+import { Logger } from "./Logger.mjs";
+import { Profiler } from "./Profiler.mjs";
+import { State, createState } from "./State.mjs";
+import { useState } from "./useState.mjs";
+export { Galena, Logger, Middleware, Profiler, State, connect, connectMulti, createGalena, createGalenaProvider, createState, createUseState, useState };

package/dist/types.d.cts

@@ -0,0 +1,23 @@
+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"]>;
+type SetDifference<A, B> = A extends B ? never : A;
+type SetComplement<A, A1 extends A> = SetDifference<A, A1>;
+type Subtract<T extends T1, T1 extends object> = Pick<T, SetComplement<keyof T, keyof T1>>;
+type DerivedArguments<StateInstances extends State<any>[]> = { [I in keyof StateInstances]: ReturnType<StateInstances[I]["getSnapshot"]> } & {
+  length: number;
+};
+type DerivedSelector<StateInstances extends State<any>[]> = (state: DerivedArguments<StateInstances>, ownProps: any) => Record<string, any>;
+//#endregion
+export { AppSubscriber, DerivedArguments, DerivedSelector, GalenaSnapshot, NonFunction, PartialSupport, SetComplement, SetDifference, Setter, StateTypes, Subscriber, Subtract };
+//# 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;AAAA,KAGE,aAAA,SAAsB,CAAA,SAAU,CAAA,WAAY,CAAA;AAAA,KAE5C,aAAA,eAA4B,CAAA,IAAK,aAAA,CAAc,CAAA,EAAG,EAAA;AAAA,KAElD,QAAA,WAAmB,EAAA,uBAAyB,IAAA,CACtD,CAAA,EACA,aAAA,OAAoB,CAAA,QAAS,EAAA;AAAA,KAGnB,gBAAA,wBAAwC,KAAA,yBACtC,cAAA,GAAiB,UAAA,CAAW,cAAA,CAAe,CAAA;EACnD,MAAA;AAAA;AAAA,KAEM,eAAA,wBAAuC,KAAA,YACjD,KAAA,EAAO,gBAAA,CAAiB,cAAA,GACxB,QAAA,UACG,MAAA"}

package/dist/types.d.mts

@@ -0,0 +1,23 @@
+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"]>;
+type SetDifference<A, B> = A extends B ? never : A;
+type SetComplement<A, A1 extends A> = SetDifference<A, A1>;
+type Subtract<T extends T1, T1 extends object> = Pick<T, SetComplement<keyof T, keyof T1>>;
+type DerivedArguments<StateInstances extends State<any>[]> = { [I in keyof StateInstances]: ReturnType<StateInstances[I]["getSnapshot"]> } & {
+  length: number;
+};
+type DerivedSelector<StateInstances extends State<any>[]> = (state: DerivedArguments<StateInstances>, ownProps: any) => Record<string, any>;
+//#endregion
+export { AppSubscriber, DerivedArguments, DerivedSelector, GalenaSnapshot, NonFunction, PartialSupport, SetComplement, SetDifference, Setter, StateTypes, Subscriber, Subtract };
+//# 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;AAAA,KAGE,aAAA,SAAsB,CAAA,SAAU,CAAA,WAAY,CAAA;AAAA,KAE5C,aAAA,eAA4B,CAAA,IAAK,aAAA,CAAc,CAAA,EAAG,EAAA;AAAA,KAElD,QAAA,WAAmB,EAAA,uBAAyB,IAAA,CACtD,CAAA,EACA,aAAA,OAAoB,CAAA,QAAS,EAAA;AAAA,KAGnB,gBAAA,wBAAwC,KAAA,yBACtC,cAAA,GAAiB,UAAA,CAAW,cAAA,CAAe,CAAA;EACnD,MAAA;AAAA;AAAA,KAEM,eAAA,wBAAuC,KAAA,YACjD,KAAA,EAAO,gBAAA,CAAiB,cAAA,GACxB,QAAA,UACG,MAAA"}

package/dist/useState.cjs

@@ -0,0 +1,45 @@
+const require_commonHooks = require("./commonHooks.cjs");
+const require_State = require("./State.cjs");
+let react = require("react");
+//#region src/useState.ts
+/**
+* Use State
+*
+* A `State` consumer/creator for your react components.
+* This hook can accept an exising instance of `State` or
+* a stateful value and return reactive state and updaters
+* for your components
+*
+* ```typescript
+* import { State, useState } from "@figliolia/galena";
+*
+* const myState = new State("<some-value>");
+*
+* export const MyComponent = () => {
+*   const [state, setState] = useState(myState);
+*   // or useState can be used a standalone replacement for React's useState
+*   const [state, setState] = useState("<some-value>");
+*
+*   return (
+*     // your jsx
+*   );
+* }
+* ```
+*
+* `useState` can also accept an optional selector function for deriving
+* values from a unit of state
+*
+* ```typescript
+* import { State, useState } from "@figliolia/galena";
+*
+* const myState = new State({ deeply: { nested: data: 4 } });
+*
+* const eight = useState(myState, state => deeply.nested.data * 2);
+* ```
+*/
+const useState = (value, selector = ((value) => value)) => {
+	const stableSelector = require_commonHooks.useStableSelector(selector);
+	return require_commonHooks.useStateHookAPI((0, react.useMemo)(() => value instanceof require_State.State ? value : new require_State.State(value), [value]), stableSelector);
+};
+//#endregion
+exports.useState = useState;

package/dist/useState.d.cts

@@ -0,0 +1,43 @@
+import { NonFunction, Setter } from "./types.cjs";
+import { State } from "./State.cjs";
+
+//#region src/useState.d.ts
+/**
+ * Use State
+ *
+ * A `State` consumer/creator for your react components.
+ * This hook can accept an exising instance of `State` or
+ * a stateful value and return reactive state and updaters
+ * for your components
+ *
+ * ```typescript
+ * import { State, useState } from "@figliolia/galena";
+ *
+ * const myState = new State("<some-value>");
+ *
+ * export const MyComponent = () => {
+ *   const [state, setState] = useState(myState);
+ *   // or useState can be used a standalone replacement for React's useState
+ *   const [state, setState] = useState("<some-value>");
+ *
+ *   return (
+ *     // your jsx
+ *   );
+ * }
+ * ```
+ *
+ * `useState` can also accept an optional selector function for deriving
+ * values from a unit of state
+ *
+ * ```typescript
+ * import { State, useState } from "@figliolia/galena";
+ *
+ * const myState = new State({ deeply: { nested: data: 4 } });
+ *
+ * const eight = useState(myState, state => deeply.nested.data * 2);
+ * ```
+ */
+declare const useState: <T, U = T>(value: NonFunction<T> | State<T>, selector?: (value: NonFunction<T>) => U) => readonly [U, (setter: Setter<T>) => void];
+//#endregion
+export { useState };
+//# sourceMappingURL=useState.d.cts.map

package/dist/useState.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.d.cts","names":[],"sources":["../src/useState.ts"],"mappings":";;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,QAAA,UAAmB,CAAA,EAC9B,KAAA,EAAO,WAAA,CAAY,CAAA,IAAK,KAAA,CAAM,CAAA,GAC9B,QAAA,IAAkD,KAAA,EAAO,WAAA,CAAY,CAAA,MAAO,CAAA,eAAC,CAAA,GAAA,MAAA,EAAA,MAAA,CAAA,CAAA"}

package/dist/useState.d.mts

@@ -0,0 +1,43 @@
+import { NonFunction, Setter } from "./types.mjs";
+import { State } from "./State.mjs";
+
+//#region src/useState.d.ts
+/**
+ * Use State
+ *
+ * A `State` consumer/creator for your react components.
+ * This hook can accept an exising instance of `State` or
+ * a stateful value and return reactive state and updaters
+ * for your components
+ *
+ * ```typescript
+ * import { State, useState } from "@figliolia/galena";
+ *
+ * const myState = new State("<some-value>");
+ *
+ * export const MyComponent = () => {
+ *   const [state, setState] = useState(myState);
+ *   // or useState can be used a standalone replacement for React's useState
+ *   const [state, setState] = useState("<some-value>");
+ *
+ *   return (
+ *     // your jsx
+ *   );
+ * }
+ * ```
+ *
+ * `useState` can also accept an optional selector function for deriving
+ * values from a unit of state
+ *
+ * ```typescript
+ * import { State, useState } from "@figliolia/galena";
+ *
+ * const myState = new State({ deeply: { nested: data: 4 } });
+ *
+ * const eight = useState(myState, state => deeply.nested.data * 2);
+ * ```
+ */
+declare const useState: <T, U = T>(value: NonFunction<T> | State<T>, selector?: (value: NonFunction<T>) => U) => readonly [U, (setter: Setter<T>) => void];
+//#endregion
+export { useState };
+//# sourceMappingURL=useState.d.mts.map

package/dist/useState.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.d.mts","names":[],"sources":["../src/useState.ts"],"mappings":";;;;;;AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,QAAA,UAAmB,CAAA,EAC9B,KAAA,EAAO,WAAA,CAAY,CAAA,IAAK,KAAA,CAAM,CAAA,GAC9B,QAAA,IAAkD,KAAA,EAAO,WAAA,CAAY,CAAA,MAAO,CAAA,eAAC,CAAA,GAAA,MAAA,EAAA,MAAA,CAAA,CAAA"}

package/dist/useState.mjs

@@ -0,0 +1,47 @@
+import { useStableSelector, useStateHookAPI } from "./commonHooks.mjs";
+import { State } from "./State.mjs";
+import { useMemo } from "react";
+//#region src/useState.ts
+/**
+* Use State
+*
+* A `State` consumer/creator for your react components.
+* This hook can accept an exising instance of `State` or
+* a stateful value and return reactive state and updaters
+* for your components
+*
+* ```typescript
+* import { State, useState } from "@figliolia/galena";
+*
+* const myState = new State("<some-value>");
+*
+* export const MyComponent = () => {
+*   const [state, setState] = useState(myState);
+*   // or useState can be used a standalone replacement for React's useState
+*   const [state, setState] = useState("<some-value>");
+*
+*   return (
+*     // your jsx
+*   );
+* }
+* ```
+*
+* `useState` can also accept an optional selector function for deriving
+* values from a unit of state
+*
+* ```typescript
+* import { State, useState } from "@figliolia/galena";
+*
+* const myState = new State({ deeply: { nested: data: 4 } });
+*
+* const eight = useState(myState, state => deeply.nested.data * 2);
+* ```
+*/
+const useState = (value, selector = ((value) => value)) => {
+	const stableSelector = useStableSelector(selector);
+	return useStateHookAPI(useMemo(() => value instanceof State ? value : new State(value), [value]), stableSelector);
+};
+//#endregion
+export { useState };
+
+//# sourceMappingURL=useState.mjs.map

package/dist/useState.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useState.mjs","names":[],"sources":["../src/useState.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useStableSelector, useStateHookAPI } from \"./commonHooks\";\nimport { State } from \"./State\";\nimport type { NonFunction } from \"./types\";\n\n/**\n * Use State\n *\n * A `State` consumer/creator for your react components.\n * This hook can accept an exising instance of `State` or\n * a stateful value and return reactive state and updaters\n * for your components\n *\n * ```typescript\n * import { State, useState } from \"@figliolia/galena\";\n *\n * const myState = new State(\"<some-value>\");\n *\n * export const MyComponent = () => {\n *   const [state, setState] = useState(myState);\n *   // or useState can be used a standalone replacement for React's useState\n *   const [state, setState] = useState(\"<some-value>\");\n *\n *   return (\n *     // your jsx\n *   );\n * }\n * ```\n *\n * `useState` can also accept an optional selector function for deriving\n * values from a unit of state\n *\n * ```typescript\n * import { State, useState } from \"@figliolia/galena\";\n *\n * const myState = new State({ deeply: { nested: data: 4 } });\n *\n * const eight = useState(myState, state => deeply.nested.data * 2);\n * ```\n */\nexport const useState = <T, U = T>(\n  value: NonFunction<T> | State<T>,\n  selector = ((value: NonFunction<T>) => value) as (value: NonFunction<T>) => U,\n) => {\n  const stableSelector = useStableSelector(selector);\n  const readable = useMemo(\n    () => (value instanceof State ? value : new State(value)),\n    [value],\n  );\n  return useStateHookAPI(readable, stableSelector);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAa,YACX,OACA,aAAa,UAA0B,WACpC;CACH,MAAM,iBAAiB,kBAAkB,SAAS;AAKlD,QAAO,gBAJU,cACR,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,MAAM,EACxD,CAAC,MAAM,CACR,EACgC,eAAe"}