@j13b/react-state 0.1.0

package/dist/cjs/hooks/use_runner_status.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRunnerStatus = useRunnerStatus;
+const use_signal_value_js_1 = require("./use_signal_value.js");
+/**
+ * A hook that subscribes to a runner's status changes and returns the current status.
+ * The component will re-render whenever the runner's status changes.
+ *
+ * @template T - The type of the runner's value
+ * @param broadcast - The broadcast interface of the runner to subscribe to
+ * @returns The current status of the runner (INITIAL, PENDING, SUCCESS, ERROR)
+ *
+ * @example
+ * ```tsx
+ * const status = useRunnerStatus(runner.broadcast);
+ *
+ * return (
+ *   <div>
+ *     {status === 'PENDING' && <Spinner />}
+ *     {status === 'ERROR' && <ErrorMessage />}
+ *     {status === 'SUCCESS' && <SuccessMessage />}
+ *   </div>
+ * );
+ * ```
+ */
+function useRunnerStatus(broadcast) {
+    return (0, use_signal_value_js_1.useSignalValue)(broadcast.stateBroadcast).status;
+}

package/dist/cjs/hooks/use_runner_status_effect.d.ts

@@ -0,0 +1,24 @@
+import { IRunnerBroadcast, Status } from '@j13b/state';
+/**
+ * A hook that runs an effect whenever a runner's status changes.
+ * This is useful for side effects that need to respond to runner status changes
+ * without causing a re-render.
+ *
+ * @template T - The type of the runner's value
+ * @param callback - The effect to run when the runner's status changes
+ * @param task - The broadcast interface of the runner to subscribe to
+ *
+ * @example
+ * ```tsx
+ * useRunnerStatusEffect(
+ *   status => {
+ *     if (status === 'ERROR') {
+ *       // Handle error state
+ *       showErrorToast();
+ *     }
+ *   },
+ *   runner.broadcast
+ * );
+ * ```
+ */
+export declare function useRunnerStatusEffect(callback: (value: Status) => void, task: IRunnerBroadcast<any>): void;

package/dist/cjs/hooks/use_runner_status_effect.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRunnerStatusEffect = useRunnerStatusEffect;
+const use_signal_value_effect_js_1 = require("./use_signal_value_effect.js");
+/**
+ * A hook that runs an effect whenever a runner's status changes.
+ * This is useful for side effects that need to respond to runner status changes
+ * without causing a re-render.
+ *
+ * @template T - The type of the runner's value
+ * @param callback - The effect to run when the runner's status changes
+ * @param task - The broadcast interface of the runner to subscribe to
+ *
+ * @example
+ * ```tsx
+ * useRunnerStatusEffect(
+ *   status => {
+ *     if (status === 'ERROR') {
+ *       // Handle error state
+ *       showErrorToast();
+ *     }
+ *   },
+ *   runner.broadcast
+ * );
+ * ```
+ */
+function useRunnerStatusEffect(callback, task) {
+    return (0, use_signal_value_effect_js_1.useSignalValueEffect)(state => {
+        callback(state.status);
+    }, task.stateBroadcast);
+}

package/dist/cjs/hooks/use_signal_value.d.ts

@@ -0,0 +1,38 @@
+import { IBroadcast } from '@j13b/state';
+/**
+ * A hook that subscribes to a signal's value changes and returns the current value.
+ * The component re-renders when the signal broadcasts. Notifications are batched
+ * by React: a burst of synchronous emissions (e.g. several `set()` calls in one
+ * event tick) renders once with the latest value — intermediate states are never
+ * painted.
+ *
+ * Built on React 18's `useSyncExternalStore`, which makes the hook:
+ * - Tear-free under concurrent rendering (React re-checks the snapshot after render).
+ * - SSR-safe: on the server the current value is rendered via the server snapshot
+ *   without subscribing (no `useLayoutEffect` warnings).
+ *
+ * The snapshot is the broadcast's monotonically increasing `version` rather than
+ * the value itself. This guarantees that no emission is silently ignored:
+ * `Signal.transform()` mutates the value in place and returns the SAME reference,
+ * so value/reference equality (`Object.is`) cannot detect the change — the version
+ * counter is what makes in-place transforms render. A consequence is that a
+ * `set()` of an identical value also triggers one render, since without a deep
+ * comparison it is indistinguishable from an in-place mutation.
+ *
+ * The subscription object returned by `broadcast.subscribe()` is strongly held by
+ * the unsubscribe closure for the lifetime of the subscription (the signal itself
+ * only holds it via WeakRef), and is unsubscribed when the component unmounts or
+ * the broadcast changes.
+ *
+ * @template TValue - The type of the signal's value
+ * @param broadcast - The broadcast interface of the signal to subscribe to
+ * @returns The current value of the signal
+ *
+ * @example
+ * ```tsx
+ * const value = useSignalValue(signal.broadcast);
+ *
+ * return <div>Current value: {value}</div>;
+ * ```
+ */
+export declare function useSignalValue<TValue>(broadcast: IBroadcast<TValue>): TValue;

package/dist/cjs/hooks/use_signal_value.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignalValue = useSignalValue;
+const react_1 = require("react");
+/**
+ * A hook that subscribes to a signal's value changes and returns the current value.
+ * The component re-renders when the signal broadcasts. Notifications are batched
+ * by React: a burst of synchronous emissions (e.g. several `set()` calls in one
+ * event tick) renders once with the latest value — intermediate states are never
+ * painted.
+ *
+ * Built on React 18's `useSyncExternalStore`, which makes the hook:
+ * - Tear-free under concurrent rendering (React re-checks the snapshot after render).
+ * - SSR-safe: on the server the current value is rendered via the server snapshot
+ *   without subscribing (no `useLayoutEffect` warnings).
+ *
+ * The snapshot is the broadcast's monotonically increasing `version` rather than
+ * the value itself. This guarantees that no emission is silently ignored:
+ * `Signal.transform()` mutates the value in place and returns the SAME reference,
+ * so value/reference equality (`Object.is`) cannot detect the change — the version
+ * counter is what makes in-place transforms render. A consequence is that a
+ * `set()` of an identical value also triggers one render, since without a deep
+ * comparison it is indistinguishable from an in-place mutation.
+ *
+ * The subscription object returned by `broadcast.subscribe()` is strongly held by
+ * the unsubscribe closure for the lifetime of the subscription (the signal itself
+ * only holds it via WeakRef), and is unsubscribed when the component unmounts or
+ * the broadcast changes.
+ *
+ * @template TValue - The type of the signal's value
+ * @param broadcast - The broadcast interface of the signal to subscribe to
+ * @returns The current value of the signal
+ *
+ * @example
+ * ```tsx
+ * const value = useSignalValue(signal.broadcast);
+ *
+ * return <div>Current value: {value}</div>;
+ * ```
+ */
+function useSignalValue(broadcast) {
+    const subscribe = (0, react_1.useCallback)((onStoreChange) => {
+        // `subscription` must be strongly referenced: the signal only keeps a
+        // WeakRef to it, so this closure is what keeps the callback alive.
+        const subscription = broadcast.subscribe(onStoreChange);
+        return () => subscription.unsubscribe();
+    }, [broadcast]);
+    // Version snapshot (deliberate): transform() mutates in place and returns the
+    // same reference, so Object.is on the value would miss changes. The version
+    // increments on every set(), so no emission is ignored (React coalesces a
+    // synchronous burst into a single render of the latest value). Do not
+    // snapshot the value.
+    const getSnapshot = (0, react_1.useCallback)(() => broadcast.version, [broadcast]);
+    (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    return broadcast.get();
+}

package/dist/cjs/hooks/use_signal_value_effect.d.ts

@@ -0,0 +1,34 @@
+import type { IBroadcast } from '@j13b/state';
+/**
+ * A hook that runs an effect whenever a signal's value changes.
+ * This is useful for side effects that need to respond to signal value changes
+ * without causing a re-render.
+ *
+ * Contract:
+ * - The callback fires exactly once with the current value on mount, and again
+ *   once whenever the `broadcast` identity changes (with the new broadcast's
+ *   current value).
+ * - After that, it fires exactly once per emission — including emissions of an
+ *   identical value (every `set()` notifies subscribers). No double-fires.
+ * - The latest `callback` prop is always used; changing the callback does not
+ *   re-subscribe or re-fire.
+ * - The subscription object is strongly held for the component's lifetime (the
+ *   signal itself only holds it via WeakRef) and is cleaned up on unmount or
+ *   when the broadcast changes.
+ *
+ * @template T - The type of the signal's value
+ * @param callback - The effect to run when the signal's value changes
+ * @param broadcast - The broadcast interface of the signal to subscribe to
+ *
+ * @example
+ * ```tsx
+ * useSignalValueEffect(
+ *   value => {
+ *     // Do something with the new value
+ *     console.log('Value changed:', value);
+ *   },
+ *   signal.broadcast
+ * );
+ * ```
+ */
+export declare function useSignalValueEffect<T>(callback: (value: T) => void, broadcast: IBroadcast<T>): void;

package/dist/cjs/hooks/use_signal_value_effect.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSignalValueEffect = useSignalValueEffect;
+const react_1 = require("react");
+// useLayoutEffect warns during server-side rendering; fall back to useEffect
+// there. Effects never run on the server either way, so behavior is identical.
+const useIsomorphicLayoutEffect = typeof window !== 'undefined' ? react_1.useLayoutEffect : react_1.useEffect;
+/**
+ * A hook that runs an effect whenever a signal's value changes.
+ * This is useful for side effects that need to respond to signal value changes
+ * without causing a re-render.
+ *
+ * Contract:
+ * - The callback fires exactly once with the current value on mount, and again
+ *   once whenever the `broadcast` identity changes (with the new broadcast's
+ *   current value).
+ * - After that, it fires exactly once per emission — including emissions of an
+ *   identical value (every `set()` notifies subscribers). No double-fires.
+ * - The latest `callback` prop is always used; changing the callback does not
+ *   re-subscribe or re-fire.
+ * - The subscription object is strongly held for the component's lifetime (the
+ *   signal itself only holds it via WeakRef) and is cleaned up on unmount or
+ *   when the broadcast changes.
+ *
+ * @template T - The type of the signal's value
+ * @param callback - The effect to run when the signal's value changes
+ * @param broadcast - The broadcast interface of the signal to subscribe to
+ *
+ * @example
+ * ```tsx
+ * useSignalValueEffect(
+ *   value => {
+ *     // Do something with the new value
+ *     console.log('Value changed:', value);
+ *   },
+ *   signal.broadcast
+ * );
+ * ```
+ */
+function useSignalValueEffect(callback, broadcast) {
+    const callbackRef = (0, react_1.useRef)(callback);
+    // Declared before the subscription effect so the ref is up to date when the
+    // subscription effect (re-)runs in the same commit.
+    useIsomorphicLayoutEffect(() => {
+        callbackRef.current = callback;
+    }, [callback]);
+    useIsomorphicLayoutEffect(() => {
+        // `subscription` is strongly referenced by this effect's closure: the
+        // signal only keeps a WeakRef to it, so this is what keeps it alive.
+        const subscription = broadcast.subscribe(value => {
+            callbackRef.current(value);
+        });
+        // Fire exactly once with the current value on mount / broadcast change.
+        // Subsequent emissions arrive through the subscription above.
+        callbackRef.current(broadcast.get());
+        return () => {
+            subscription.unsubscribe();
+        };
+    }, [broadcast]);
+}

package/dist/cjs/hooks/use_update.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A hook that provides a way to force component re-renders.
+ *
+ * @returns A function that triggers a re-render when called
+ *
+ * @example
+ * ```tsx
+ * const update = useUpdate();
+ *
+ * // Force a re-render
+ * update();
+ * ```
+ */
+export declare const useUpdate: () => () => void;

package/dist/cjs/hooks/use_update.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUpdate = void 0;
+const react_1 = require("react");
+const updateReducer = (num) => (num + 1) % 1_000_000;
+/**
+ * A hook that provides a way to force component re-renders.
+ *
+ * @returns A function that triggers a re-render when called
+ *
+ * @example
+ * ```tsx
+ * const update = useUpdate();
+ *
+ * // Force a re-render
+ * update();
+ * ```
+ */
+const useUpdate = () => {
+    const [, update] = (0, react_1.useReducer)(updateReducer, 0);
+    return update;
+};
+exports.useUpdate = useUpdate;

package/dist/cjs/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * React bindings for @j13b/state.
+ * Hooks for subscribing to Signals, Runners, and Broadcasts from React
+ * components. Requires react and @j13b/state as peer dependencies.
+ *
+ * @example
+ * ```typescript
+ * import { useSignalValue, useRunnerStatus } from '@j13b/react-state';
+ * ```
+ */
+export * from './hooks/use_signal_value.js';
+export * from './hooks/use_signal_value_effect.js';
+export * from './hooks/use_update.js';
+export * from './hooks/use_runner_status.js';
+export * from './hooks/use_runner_status_effect.js';
+export * from './hooks/use_runner_error.js';
+export * from './hooks/use_runner_error_effect.js';
+export * from './hooks/use_runner_progress.js';
+export * from './hooks/use_runner_progress_effect.js';
+export * from './hooks/use_runner_feedback.js';
+export * from './hooks/use_runner_feedback_effect.js';

package/dist/cjs/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * React bindings for @j13b/state.
+ * Hooks for subscribing to Signals, Runners, and Broadcasts from React
+ * components. Requires react and @j13b/state as peer dependencies.
+ *
+ * @example
+ * ```typescript
+ * import { useSignalValue, useRunnerStatus } from '@j13b/react-state';
+ * ```
+ */
+__exportStar(require("./hooks/use_signal_value.js"), exports);
+__exportStar(require("./hooks/use_signal_value_effect.js"), exports);
+__exportStar(require("./hooks/use_update.js"), exports);
+__exportStar(require("./hooks/use_runner_status.js"), exports);
+__exportStar(require("./hooks/use_runner_status_effect.js"), exports);
+__exportStar(require("./hooks/use_runner_error.js"), exports);
+__exportStar(require("./hooks/use_runner_error_effect.js"), exports);
+__exportStar(require("./hooks/use_runner_progress.js"), exports);
+__exportStar(require("./hooks/use_runner_progress_effect.js"), exports);
+__exportStar(require("./hooks/use_runner_feedback.js"), exports);
+__exportStar(require("./hooks/use_runner_feedback_effect.js"), exports);

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/hooks/use_runner_error.d.ts

@@ -0,0 +1,26 @@
+import { IRunnerBroadcast } from '@j13b/state';
+/**
+ * A React hook that subscribes to the error state of a runner.
+ *
+ * @template T - The type of value that the runner manages
+ * @param {IRunnerBroadcast<T>} task - The runner broadcast interface to subscribe to
+ * @returns {Error | null} The current error state of the runner, or null if there is no error
+ *
+ * @example
+ * ```tsx
+ * const error = useRunnerError(saveRunner.broadcast);
+ * if (error) {
+ *   return <ErrorMessage error={error} />;
+ * }
+ * ```
+ *
+ * @remarks
+ * This hook is useful for:
+ * - Displaying error messages in the UI
+ * - Conditionally rendering error states
+ * - Triggering error handling logic
+ *
+ * The hook will automatically unsubscribe when the component unmounts.
+ */
+export declare function useRunnerError(task: IRunnerBroadcast<any>): Error | null;
+//# sourceMappingURL=use_runner_error.d.ts.map

package/dist/hooks/use_runner_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_error.d.ts","sourceRoot":"","sources":["../../src/hooks/use_runner_error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,gBAEzD"}

package/dist/hooks/use_runner_error.js

@@ -0,0 +1,32 @@
+import { useSignalValue } from "./use_signal_value.js";
+//#region src/hooks/use_runner_error.ts
+/**
+* A React hook that subscribes to the error state of a runner.
+*
+* @template T - The type of value that the runner manages
+* @param {IRunnerBroadcast<T>} task - The runner broadcast interface to subscribe to
+* @returns {Error | null} The current error state of the runner, or null if there is no error
+*
+* @example
+* ```tsx
+* const error = useRunnerError(saveRunner.broadcast);
+* if (error) {
+*   return <ErrorMessage error={error} />;
+* }
+* ```
+*
+* @remarks
+* This hook is useful for:
+* - Displaying error messages in the UI
+* - Conditionally rendering error states
+* - Triggering error handling logic
+*
+* The hook will automatically unsubscribe when the component unmounts.
+*/
+function useRunnerError(task) {
+	return useSignalValue(task.stateBroadcast).error;
+}
+//#endregion
+export { useRunnerError };
+
+//# sourceMappingURL=use_runner_error.js.map

package/dist/hooks/use_runner_error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_error.js","names":[],"sources":["../../src/hooks/use_runner_error.ts"],"sourcesContent":["import { IRunnerBroadcast } from '@j13b/state';\nimport { useSignalValue } from './use_signal_value.js';\n\n/**\n * A React hook that subscribes to the error state of a runner.\n *\n * @template T - The type of value that the runner manages\n * @param {IRunnerBroadcast<T>} task - The runner broadcast interface to subscribe to\n * @returns {Error | null} The current error state of the runner, or null if there is no error\n *\n * @example\n * ```tsx\n * const error = useRunnerError(saveRunner.broadcast);\n * if (error) {\n *   return <ErrorMessage error={error} />;\n * }\n * ```\n *\n * @remarks\n * This hook is useful for:\n * - Displaying error messages in the UI\n * - Conditionally rendering error states\n * - Triggering error handling logic\n *\n * The hook will automatically unsubscribe when the component unmounts.\n */\nexport function useRunnerError(task: IRunnerBroadcast<any>) {\n  return useSignalValue(task.stateBroadcast).error;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,eAAe,MAA6B;CAC1D,OAAO,eAAe,KAAK,cAAc,CAAC,CAAC;AAC7C"}

package/dist/hooks/use_runner_error_effect.d.ts

@@ -0,0 +1,29 @@
+import { IRunnerBroadcast } from '@j13b/state';
+/**
+ * A React hook that executes a callback whenever the error state of a Runner changes.
+ * This hook is useful for handling side effects that need to respond to error states
+ * in async operations managed by a Runner.
+ *
+ * @template T - The type of value managed by the Runner
+ * @param callback - A function that will be called with the current error state
+ * @param task - The Runner instance to monitor for error changes
+ * @returns void
+ *
+ * @example
+ * ```tsx
+ * useRunnerErrorEffect((error) => {
+ *   if (error) {
+ *     // Handle the error, e.g., show a notification
+ *     showErrorNotification(error.message);
+ *   }
+ * }, myRunner);
+ * ```
+ *
+ * @remarks
+ * - The callback will be called immediately with the current error state
+ * - The callback will be called whenever the error state changes
+ * - The hook automatically handles cleanup on component unmount
+ * - This hook is built on top of useSignalValueEffect for efficient state tracking
+ */
+export declare function useRunnerErrorEffect(callback: (error: Error | null) => void, task: IRunnerBroadcast<any>): void;
+//# sourceMappingURL=use_runner_error_effect.d.ts.map

package/dist/hooks/use_runner_error_effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_error_effect.d.ts","sourceRoot":"","sources":["../../src/hooks/use_runner_error_effect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,EACvC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,QAK5B"}

package/dist/hooks/use_runner_error_effect.js

@@ -0,0 +1,37 @@
+import { useSignalValueEffect } from "./use_signal_value_effect.js";
+//#region src/hooks/use_runner_error_effect.ts
+/**
+* A React hook that executes a callback whenever the error state of a Runner changes.
+* This hook is useful for handling side effects that need to respond to error states
+* in async operations managed by a Runner.
+*
+* @template T - The type of value managed by the Runner
+* @param callback - A function that will be called with the current error state
+* @param task - The Runner instance to monitor for error changes
+* @returns void
+*
+* @example
+* ```tsx
+* useRunnerErrorEffect((error) => {
+*   if (error) {
+*     // Handle the error, e.g., show a notification
+*     showErrorNotification(error.message);
+*   }
+* }, myRunner);
+* ```
+*
+* @remarks
+* - The callback will be called immediately with the current error state
+* - The callback will be called whenever the error state changes
+* - The hook automatically handles cleanup on component unmount
+* - This hook is built on top of useSignalValueEffect for efficient state tracking
+*/
+function useRunnerErrorEffect(callback, task) {
+	return useSignalValueEffect((state) => {
+		callback(state.error);
+	}, task.stateBroadcast);
+}
+//#endregion
+export { useRunnerErrorEffect };
+
+//# sourceMappingURL=use_runner_error_effect.js.map

package/dist/hooks/use_runner_error_effect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_error_effect.js","names":[],"sources":["../../src/hooks/use_runner_error_effect.ts"],"sourcesContent":["import { IRunnerBroadcast } from '@j13b/state';\nimport { useSignalValueEffect } from './use_signal_value_effect.js';\n\n/**\n * A React hook that executes a callback whenever the error state of a Runner changes.\n * This hook is useful for handling side effects that need to respond to error states\n * in async operations managed by a Runner.\n *\n * @template T - The type of value managed by the Runner\n * @param callback - A function that will be called with the current error state\n * @param task - The Runner instance to monitor for error changes\n * @returns void\n *\n * @example\n * ```tsx\n * useRunnerErrorEffect((error) => {\n *   if (error) {\n *     // Handle the error, e.g., show a notification\n *     showErrorNotification(error.message);\n *   }\n * }, myRunner);\n * ```\n *\n * @remarks\n * - The callback will be called immediately with the current error state\n * - The callback will be called whenever the error state changes\n * - The hook automatically handles cleanup on component unmount\n * - This hook is built on top of useSignalValueEffect for efficient state tracking\n */\nexport function useRunnerErrorEffect(\n  callback: (error: Error | null) => void,\n  task: IRunnerBroadcast<any>\n) {\n  return useSignalValueEffect(state => {\n    callback(state.error);\n  }, task.stateBroadcast);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,SAAgB,qBACd,UACA,MACA;CACA,OAAO,sBAAqB,UAAS;EACnC,SAAS,MAAM,KAAK;CACtB,GAAG,KAAK,cAAc;AACxB"}

package/dist/hooks/use_runner_feedback.d.ts

@@ -0,0 +1,21 @@
+import { IRunnerBroadcast } from '@j13b/state';
+/**
+ * Hook that provides access to the feedback message from a Runner's state.
+ *
+ * @template T - The type of the Runner's value
+ * @param {IRunnerBroadcast<T>} task - The Runner broadcast interface to subscribe to
+ * @returns {string | undefined} The current feedback message, or undefined if no feedback is set
+ *
+ * @example
+ * ```tsx
+ * const feedback = useRunnerFeedback(saveRunner.broadcast);
+ * return <div>{feedback}</div>;
+ * ```
+ *
+ * @remarks
+ * This hook is useful for displaying status messages to users during async operations.
+ * The feedback message is typically set using the Runner's setFeedback method.
+ * The component will automatically re-render when the feedback message changes.
+ */
+export declare function useRunnerFeedback(task: IRunnerBroadcast<any>): string;
+//# sourceMappingURL=use_runner_feedback.d.ts.map

package/dist/hooks/use_runner_feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_feedback.d.ts","sourceRoot":"","sources":["../../src/hooks/use_runner_feedback.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,UAE5D"}

package/dist/hooks/use_runner_feedback.js

@@ -0,0 +1,27 @@
+import { useSignalValue } from "./use_signal_value.js";
+//#region src/hooks/use_runner_feedback.ts
+/**
+* Hook that provides access to the feedback message from a Runner's state.
+*
+* @template T - The type of the Runner's value
+* @param {IRunnerBroadcast<T>} task - The Runner broadcast interface to subscribe to
+* @returns {string | undefined} The current feedback message, or undefined if no feedback is set
+*
+* @example
+* ```tsx
+* const feedback = useRunnerFeedback(saveRunner.broadcast);
+* return <div>{feedback}</div>;
+* ```
+*
+* @remarks
+* This hook is useful for displaying status messages to users during async operations.
+* The feedback message is typically set using the Runner's setFeedback method.
+* The component will automatically re-render when the feedback message changes.
+*/
+function useRunnerFeedback(task) {
+	return useSignalValue(task.stateBroadcast).feedback;
+}
+//#endregion
+export { useRunnerFeedback };
+
+//# sourceMappingURL=use_runner_feedback.js.map

package/dist/hooks/use_runner_feedback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_feedback.js","names":[],"sources":["../../src/hooks/use_runner_feedback.ts"],"sourcesContent":["/**\n * @module hooks/use_runner_feedback\n *\n * This module provides a hook for accessing the feedback message from a Runner's state.\n * It is useful for displaying status messages to users during async operations.\n */\n\nimport { IRunnerBroadcast } from '@j13b/state';\nimport { useSignalValue } from './use_signal_value.js';\n\n/**\n * Hook that provides access to the feedback message from a Runner's state.\n *\n * @template T - The type of the Runner's value\n * @param {IRunnerBroadcast<T>} task - The Runner broadcast interface to subscribe to\n * @returns {string | undefined} The current feedback message, or undefined if no feedback is set\n *\n * @example\n * ```tsx\n * const feedback = useRunnerFeedback(saveRunner.broadcast);\n * return <div>{feedback}</div>;\n * ```\n *\n * @remarks\n * This hook is useful for displaying status messages to users during async operations.\n * The feedback message is typically set using the Runner's setFeedback method.\n * The component will automatically re-render when the feedback message changes.\n */\nexport function useRunnerFeedback(task: IRunnerBroadcast<any>) {\n  return useSignalValue(task.stateBroadcast).feedback;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,kBAAkB,MAA6B;CAC7D,OAAO,eAAe,KAAK,cAAc,CAAC,CAAC;AAC7C"}

package/dist/hooks/use_runner_feedback_effect.d.ts

@@ -0,0 +1,25 @@
+import { IRunnerBroadcast } from '@j13b/state';
+/**
+ * A React hook that executes a callback whenever the feedback message of a Runner changes.
+ *
+ * This hook is useful for displaying operation feedback to users, such as loading messages,
+ * progress updates, or error notifications. It automatically handles cleanup when the
+ * component unmounts.
+ *
+ * @example
+ * ```tsx
+ * useRunnerFeedbackEffect(
+ *   (feedback) => {
+ *     // Update UI with feedback message
+ *     setMessage(feedback);
+ *   },
+ *   myRunner.broadcast
+ * );
+ * ```
+ *
+ * @param callback - A function that will be called with the new feedback message whenever it changes
+ * @param task - The Runner's broadcast interface to subscribe to
+ * @returns void
+ */
+export declare function useRunnerFeedbackEffect(callback: (feedback: string) => void, task: IRunnerBroadcast<any>): void;
+//# sourceMappingURL=use_runner_feedback_effect.d.ts.map

package/dist/hooks/use_runner_feedback_effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use_runner_feedback_effect.d.ts","sourceRoot":"","sources":["../../src/hooks/use_runner_feedback_effect.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,EACpC,IAAI,EAAE,gBAAgB,CAAC,GAAG,CAAC,QAK5B"}

package/dist/hooks/use_runner_feedback_effect.js

@@ -0,0 +1,33 @@
+import { useSignalValueEffect } from "./use_signal_value_effect.js";
+//#region src/hooks/use_runner_feedback_effect.ts
+/**
+* A React hook that executes a callback whenever the feedback message of a Runner changes.
+*
+* This hook is useful for displaying operation feedback to users, such as loading messages,
+* progress updates, or error notifications. It automatically handles cleanup when the
+* component unmounts.
+*
+* @example
+* ```tsx
+* useRunnerFeedbackEffect(
+*   (feedback) => {
+*     // Update UI with feedback message
+*     setMessage(feedback);
+*   },
+*   myRunner.broadcast
+* );
+* ```
+*
+* @param callback - A function that will be called with the new feedback message whenever it changes
+* @param task - The Runner's broadcast interface to subscribe to
+* @returns void
+*/
+function useRunnerFeedbackEffect(callback, task) {
+	return useSignalValueEffect((state) => {
+		callback(state.feedback);
+	}, task.stateBroadcast);
+}
+//#endregion
+export { useRunnerFeedbackEffect };
+
+//# sourceMappingURL=use_runner_feedback_effect.js.map