quidproquo-web-react 0.0.253 → 0.0.255

package/lib/esm/hooks/asmj/actionProcessor/getStateReadActionProcessor.js

@@ -1,7 +1,7 @@
-import { actionResult, StateActionType } from 'quidproquo-core';
-const getProcessStateRead = (getCurrentState) => async () => {
-    return actionResult(getCurrentState());
-};
-export const getStateReadActionListResolver = (getCurrentState) => async (_qpqConfig, _dynamicModuleLoader) => ({
-    [StateActionType.Read]: getProcessStateRead(getCurrentState),
-});
+import { actionResult, StateActionType } from 'quidproquo-core';
+const getProcessStateRead = (getCurrentState) => async () => {
+    return actionResult(getCurrentState());
+};
+export const getStateReadActionListResolver = (getCurrentState) => async (_qpqConfig, _dynamicModuleLoader) => ({
+    [StateActionType.Read]: getProcessStateRead(getCurrentState),
+});

package/lib/esm/hooks/asmj/actionProcessor/index.d.ts

@@ -1,3 +1,3 @@
-import { ActionProcessorListResolver } from 'quidproquo-core';
-import { Dispatch } from 'react';
-export declare const getStateActionProcessor: <State>(dispatch: Dispatch<any>, getCurrentState: () => State) => ActionProcessorListResolver;
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { Dispatch } from 'react';
+export declare const getStateActionProcessor: <State>(dispatch: Dispatch<any>, getCurrentState: () => State) => ActionProcessorListResolver;

package/lib/esm/hooks/asmj/actionProcessor/index.js

@@ -1,6 +1,6 @@
-import { getStateDispatchActionListResolver } from './getStateDispatchActionProcessor';
-import { getStateReadActionListResolver } from './getStateReadActionProcessor';
-export const getStateActionProcessor = (dispatch, getCurrentState) => async (qpqConfig, dynamicModuleLoader) => ({
-    ...(await getStateDispatchActionListResolver(dispatch)(qpqConfig, dynamicModuleLoader)),
-    ...(await getStateReadActionListResolver(getCurrentState)(qpqConfig, dynamicModuleLoader)),
-});
+import { getStateDispatchActionListResolver } from './getStateDispatchActionProcessor';
+import { getStateReadActionListResolver } from './getStateReadActionProcessor';
+export const getStateActionProcessor = (dispatch, getCurrentState) => async (qpqConfig, dynamicModuleLoader) => ({
+    ...(await getStateDispatchActionListResolver(dispatch)(qpqConfig, dynamicModuleLoader)),
+    ...(await getStateReadActionListResolver(getCurrentState)(qpqConfig, dynamicModuleLoader)),
+});

package/lib/esm/hooks/asmj/createQpqRuntimeDefinition.d.ts

@@ -1,16 +1,22 @@
-import { atom } from 'jotai';
-import { QpqApi } from './QpqMappedApi';
-import { QpqBubbleReducer } from './QpqRuntimeEffectCatcher';
-type CustomJotaiReducerAtom<TState> = ReturnType<typeof atom<TState>>;
-export type QpqAsmjState<TState, TAction, TApi extends QpqApi> = {
-    atom: CustomJotaiReducerAtom<TState>;
-    reducer: QpqBubbleReducer<TState, TAction>;
-    initialState: TState;
-    api: TApi;
-    state: TState;
-};
-type AsmjStateGetter<TState, TAction, TApi extends QpqApi> = (name?: string) => QpqAsmjState<TState, TAction, TApi>;
-export type QpqRuntimeDefinition<TState, TAction, TApi extends QpqApi> = AsmjStateGetter<TState, TAction, TApi>;
-export declare function createQpqRuntimeDefinition<TState, TAction, TApi extends QpqApi>(api: TApi, initialState: TState, reducer?: QpqBubbleReducer<TState, TAction>): QpqRuntimeDefinition<TState, TAction, TApi>;
-export declare function useQpqRuntimeState<TState, TAction, TApi extends QpqApi>(atom: QpqRuntimeDefinition<TState, TAction, TApi>, name?: string): [TState, (newState: TState) => void, () => TState];
-export {};
+import { atom } from 'jotai';
+import { selectAtom } from 'jotai/utils';
+import { QpqApi } from './QpqMappedApi';
+import { QpqBubbleReducer } from './QpqRuntimeEffectCatcher';
+type CustomJotaiReducerAtom<TState> = ReturnType<typeof atom<TState>>;
+type CustomJotaiComputedAtom<TState, TSlice> = ReturnType<typeof selectAtom<TState, TSlice>>;
+export type QpqAsmjState<TState, TAction, TApi extends QpqApi> = {
+    atom: CustomJotaiReducerAtom<TState>;
+    reducer: QpqBubbleReducer<TState, TAction>;
+    initialState: TState;
+    api: TApi;
+    state: TState;
+};
+type AsmjStateGetter<TState, TAction, TApi extends QpqApi> = (name?: string) => QpqAsmjState<TState, TAction, TApi>;
+type AsmjStateComputer<TState, TSlice> = (name?: string) => CustomJotaiComputedAtom<TState, TSlice>;
+export type QpqRuntimeDefinition<TState, TAction, TApi extends QpqApi> = AsmjStateGetter<TState, TAction, TApi>;
+export type QpqRuntimeComputed<TState, TSlice> = AsmjStateComputer<TState, TSlice>;
+export declare function createQpqRuntimeDefinition<TState, TAction, TApi extends QpqApi>(api: TApi, initialState: TState, reducer?: QpqBubbleReducer<TState, TAction>): QpqRuntimeDefinition<TState, TAction, TApi>;
+export declare function createQpqRuntimeComputed<TState, TAction, TApi extends QpqApi, TSlice>(atom: QpqRuntimeDefinition<TState, TAction, TApi>, compute: (state: TState) => TSlice): QpqRuntimeComputed<TState, TSlice>;
+export declare function useQpqRuntimeState<TState, TAction, TApi extends QpqApi>(atom: QpqRuntimeDefinition<TState, TAction, TApi>, name?: string): [TState, (newState: TState) => void, () => TState];
+export declare function useQpqRuntimeComputed<TState, TSlice>(computedAtom: QpqRuntimeComputed<TState, TSlice>, name?: string): TSlice;
+export {};

package/lib/esm/hooks/asmj/createQpqRuntimeDefinition.js

@@ -1,34 +1,46 @@
-import { useCallback } from 'react';
-import { atom, useAtom } from 'jotai';
-export function createQpqRuntimeDefinition(api, initialState, reducer = (s) => [s, false]) {
-    const namedAtoms = new Map();
-    const getCustomNamedAtom = (name) => {
-        const actualName = name ? name : '$$qpq-default$$';
-        if (!namedAtoms.has(actualName)) {
-            console.log('Creating Atom: ', actualName);
-            const winAtom = {
-                atom: atom(initialState),
-                reducer,
-                initialState,
-                api: api,
-                state: initialState,
-            };
-            namedAtoms.set(actualName, winAtom);
-        }
-        return namedAtoms.get(actualName);
-    };
-    return getCustomNamedAtom;
-}
-export function useQpqRuntimeState(atom, name) {
-    const [state, setState] = useAtom(atom(name).atom);
-    const setStateWrapper = useCallback((newState) => {
-        const info = atom(name);
-        info.state = newState;
-        setState(newState);
-    }, [setState]);
-    const getState = useCallback(() => {
-        const state = atom(name).state;
-        return state;
-    }, [atom]);
-    return [state, setStateWrapper, getState];
-}
+import { useCallback, useMemo } from 'react';
+import { atom, useAtom } from 'jotai';
+import { selectAtom } from 'jotai/utils';
+export function createQpqRuntimeDefinition(api, initialState, reducer = (s) => [s, false]) {
+    const namedAtoms = new Map();
+    const getCustomNamedAtom = (name) => {
+        const actualName = name ? name : '$$qpq-default$$';
+        if (!namedAtoms.has(actualName)) {
+            const winAtom = {
+                atom: atom(initialState),
+                reducer,
+                initialState,
+                api: api,
+                state: initialState,
+            };
+            namedAtoms.set(actualName, winAtom);
+        }
+        return namedAtoms.get(actualName);
+    };
+    return getCustomNamedAtom;
+}
+export function createQpqRuntimeComputed(atom, compute) {
+    return (name) => {
+        const info = atom(name);
+        return selectAtom(info.atom, compute);
+    };
+}
+export function useQpqRuntimeState(atom, name) {
+    const actualAtom = useMemo(() => atom(name).atom, [atom, name]);
+    const [state, setState] = useAtom(actualAtom);
+    const setStateWrapper = useCallback((newState) => {
+        const info = atom(name);
+        info.state = newState;
+        setState(newState);
+    }, [setState]);
+    const getState = useCallback(() => {
+        const state = atom(name).state;
+        return state;
+    }, [atom, name]);
+    return [state, setStateWrapper, getState];
+}
+export function useQpqRuntimeComputed(computedAtom, name) {
+    const computedAtomValue = useMemo(() => computedAtom(name), [computedAtom, name]);
+    const [state] = useAtom(computedAtomValue);
+    return state;
+}

package/lib/esm/hooks/asmj/index.d.ts

@@ -1,6 +1,6 @@
-export * from './actionProcessor';
-export * from './createQpqRuntimeDefinition';
-export * from './QpqContextProvider';
-export * from './QpqMappedApi';
-export * from './QpqRuntimeEffectCatcher';
-export * from './useQpqRuntime';
+export * from './actionProcessor';
+export * from './createQpqRuntimeDefinition';
+export * from './QpqContextProvider';
+export * from './QpqMappedApi';
+export * from './QpqRuntimeEffectCatcher';
+export * from './useQpqRuntime';

package/lib/esm/hooks/asmj/index.js

@@ -1,6 +1,6 @@
-export * from './actionProcessor';
-export * from './createQpqRuntimeDefinition';
-export * from './QpqContextProvider';
-export * from './QpqMappedApi';
-export * from './QpqRuntimeEffectCatcher';
-export * from './useQpqRuntime';
+export * from './actionProcessor';
+export * from './createQpqRuntimeDefinition';
+export * from './QpqContextProvider';
+export * from './QpqMappedApi';
+export * from './QpqRuntimeEffectCatcher';
+export * from './useQpqRuntime';

package/lib/esm/hooks/asmj/useQpqRuntime.d.ts

@@ -1,4 +1,4 @@
-import { Story } from 'quidproquo-core';
-import { QpqApi, QpqMappedApi } from './QpqMappedApi';
-import { QpqRuntimeDefinition } from '.';
-export declare function useQpqRuntime<TState, TAction, TApi extends QpqApi>(atom: QpqRuntimeDefinition<TState, TAction, TApi>, mainStory?: Story<any, any>, name?: string): [QpqMappedApi<TApi>, TState, (action: any) => void];
+import { Story } from 'quidproquo-core';
+import { QpqApi, QpqMappedApi } from './QpqMappedApi';
+import { QpqRuntimeDefinition } from '.';
+export declare function useQpqRuntime<TState, TAction, TApi extends QpqApi>(atom: QpqRuntimeDefinition<TState, TAction, TApi>, mainStory?: Story<any, any>, name?: string): [QpqMappedApi<TApi>, TState, (action: any) => void];

package/lib/esm/hooks/asmj/useQpqRuntime.js

@@ -1,32 +1,32 @@
-import { useEffect, useMemo, useState } from 'react';
-import { useQpq } from '../useQpq';
-import { getStateActionProcessor } from './actionProcessor';
-import { useQpqRuntimeBubblingReducer } from './QpqRuntimeEffectCatcher';
-export function useQpqRuntime(atom, mainStory, name) {
-    const atomInfo = atom(name);
-    const [state, dispatch, getCurrentState] = useQpqRuntimeBubblingReducer(atom, name);
-    // Api generators are memoized to prevent unnecessary re-renders.
-    const [memoedApiGenerators] = useState(() => atomInfo.api);
-    const resolver = useQpq(getStateActionProcessor(dispatch, getCurrentState));
-    // Wrap and remap each API generator using the resolver.
-    const api = useMemo(() => {
-        const wrapped = {};
-        for (const key in memoedApiGenerators) {
-            if (Object.prototype.hasOwnProperty.call(memoedApiGenerators, key)) {
-                // Remove the 'ask' prefix and lower-case the first character.
-                const withoutAsk = key.slice(3); // e.g., "FetchTodos"
-                const newKey = withoutAsk.charAt(0).toLowerCase() + withoutAsk.slice(1); // "fetchTodos"
-                // We know newKey matches our mapped type so we can assign.
-                // (A type assertion is used here to quiet the compiler.)
-                wrapped[newKey] = resolver(memoedApiGenerators[key]);
-            }
-        }
-        return wrapped;
-    }, [resolver, memoedApiGenerators]);
-    useEffect(() => {
-        if (mainStory) {
-            resolver(mainStory)();
-        }
-    }, []);
-    return [api, state, dispatch];
-}
+import { useEffect, useMemo, useState } from 'react';
+import { useQpq } from '../useQpq';
+import { getStateActionProcessor } from './actionProcessor';
+import { useQpqRuntimeBubblingReducer } from './QpqRuntimeEffectCatcher';
+export function useQpqRuntime(atom, mainStory, name) {
+    const atomInfo = useMemo(() => atom(name), [atom, name]);
+    const [state, dispatch, getCurrentState] = useQpqRuntimeBubblingReducer(atom, name);
+    // Api generators are memoized to prevent unnecessary re-renders.
+    const [memoedApiGenerators] = useState(() => atomInfo.api);
+    const resolver = useQpq(getStateActionProcessor(dispatch, getCurrentState));
+    // Wrap and remap each API generator using the resolver.
+    const api = useMemo(() => {
+        const wrapped = {};
+        for (const key in memoedApiGenerators) {
+            if (Object.prototype.hasOwnProperty.call(memoedApiGenerators, key)) {
+                // Remove the 'ask' prefix and lower-case the first character.
+                const withoutAsk = key.slice(3); // e.g., "FetchTodos"
+                const newKey = withoutAsk.charAt(0).toLowerCase() + withoutAsk.slice(1); // "fetchTodos"
+                // We know newKey matches our mapped type so we can assign.
+                // (A type assertion is used here to quiet the compiler.)
+                wrapped[newKey] = resolver(memoedApiGenerators[key]);
+            }
+        }
+        return wrapped;
+    }, [resolver, memoedApiGenerators]);
+    useEffect(() => {
+        if (mainStory) {
+            resolver(mainStory)();
+        }
+    }, []);
+    return [api, state, dispatch];
+}

package/lib/esm/hooks/index.d.ts

@@ -1,8 +1,8 @@
-export * from './asmj';
-export * from './useAsyncEffect';
-export * from './useFastCallback';
-export * from './useMetadata';
-export * from './useOnKeyDownEffect';
-export * from './useQpq';
-export * from './useRunEvery';
-export * from './useThrottledMemo';
+export * from './asmj';
+export * from './useAsyncEffect';
+export * from './useFastCallback';
+export * from './useMetadata';
+export * from './useOnKeyDownEffect';
+export * from './useQpq';
+export * from './useRunEvery';
+export * from './useThrottledMemo';

package/lib/esm/hooks/index.js

@@ -1,8 +1,8 @@
-export * from './asmj';
-export * from './useAsyncEffect';
-export * from './useFastCallback';
-export * from './useMetadata';
-export * from './useOnKeyDownEffect';
-export * from './useQpq';
-export * from './useRunEvery';
-export * from './useThrottledMemo';
+export * from './asmj';
+export * from './useAsyncEffect';
+export * from './useFastCallback';
+export * from './useMetadata';
+export * from './useOnKeyDownEffect';
+export * from './useQpq';
+export * from './useRunEvery';
+export * from './useThrottledMemo';

package/lib/esm/hooks/useAsyncEffect.d.ts

@@ -1,2 +1,2 @@
-import { DependencyList } from 'react';
-export declare const useAsyncEffect: (effect: (isMounted: () => boolean) => Promise<void | (() => void)>, deps?: DependencyList) => void;
+import { DependencyList } from 'react';
+export declare const useAsyncEffect: (effect: (isMounted: () => boolean) => Promise<void | (() => void)>, deps?: DependencyList) => void;

package/lib/esm/hooks/useAsyncEffect.js

@@ -1,23 +1,23 @@
-import { useEffect } from 'react';
-export const useAsyncEffect = (effect, deps) => {
-    useEffect(() => {
-        const mountStatus = { mounted: true };
-        const runEffect = async () => {
-            try {
-                return await effect(() => mountStatus.mounted);
-            }
-            catch (error) {
-                console.error('Error in useAsyncEffect:', error);
-            }
-        };
-        const result = runEffect();
-        return () => {
-            mountStatus.mounted = false;
-            result.then((callback) => {
-                if (callback) {
-                    callback();
-                }
-            });
-        };
-    }, deps);
-};
+import { useEffect } from 'react';
+export const useAsyncEffect = (effect, deps) => {
+    useEffect(() => {
+        const mountStatus = { mounted: true };
+        const runEffect = async () => {
+            try {
+                return await effect(() => mountStatus.mounted);
+            }
+            catch (error) {
+                console.error('Error in useAsyncEffect:', error);
+            }
+        };
+        const result = runEffect();
+        return () => {
+            mountStatus.mounted = false;
+            result.then((callback) => {
+                if (callback) {
+                    callback();
+                }
+            });
+        };
+    }, deps);
+};

package/lib/esm/hooks/useFastCallback.d.ts

@@ -1,2 +1,2 @@
-import { DependencyList } from 'react';
-export declare function useFastCallback<T extends Function>(callback: T, deps?: DependencyList): T;
+import { DependencyList } from 'react';
+export declare function useFastCallback<T extends Function>(callback: T, deps?: DependencyList): T;

package/lib/esm/hooks/useFastCallback.js

@@ -1,16 +1,16 @@
-import { useCallback, useRef } from 'react';
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-export function useFastCallback(callback, deps) {
-    const callbackRef = useRef(callback);
-    const depsRef = useRef(deps);
-    // If the deps have changed, update the callback ref
-    // We support undefined deps, which means they are always updated
-    // This is different to [] where its never updated.
-    const hasDepsChanged = !depsRef.current || !deps || depsRef.current.some((dep, index) => dep !== deps[index]);
-    if (hasDepsChanged) {
-        callbackRef.current = callback;
-    }
-    depsRef.current = deps;
-    const memoFunc = useCallback((...args) => callbackRef.current(...args), []);
-    return memoFunc;
-}
+import { useCallback, useRef } from 'react';
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function useFastCallback(callback, deps) {
+    const callbackRef = useRef(callback);
+    const depsRef = useRef(deps);
+    // If the deps have changed, update the callback ref
+    // We support undefined deps, which means they are always updated
+    // This is different to [] where its never updated.
+    const hasDepsChanged = !depsRef.current || !deps || depsRef.current.some((dep, index) => dep !== deps[index]);
+    if (hasDepsChanged) {
+        callbackRef.current = callback;
+    }
+    depsRef.current = deps;
+    const memoFunc = useCallback((...args) => callbackRef.current(...args), []);
+    return memoFunc;
+}

package/lib/esm/hooks/useMetadata/index.d.ts

@@ -1 +1 @@
-export * from './useMetadata';
+export * from './useMetadata';

package/lib/esm/hooks/useMetadata/index.js

@@ -1 +1 @@
-export * from './useMetadata';
+export * from './useMetadata';

package/lib/esm/hooks/useMetadata/useMetadata.d.ts

@@ -1,5 +1,5 @@
-type MetadataGetter<M> = () => M | undefined;
-type MetadataSetter<M> = (value: M) => void;
-type UseMetadataReturn<M> = [MetadataGetter<M>, MetadataSetter<M>];
-export declare function useMetadata<M>(key: object): UseMetadataReturn<M>;
-export {};
+type MetadataGetter<M> = () => M | undefined;
+type MetadataSetter<M> = (value: M) => void;
+type UseMetadataReturn<M> = [MetadataGetter<M>, MetadataSetter<M>];
+export declare function useMetadata<M>(key: object): UseMetadataReturn<M>;
+export {};

package/lib/esm/hooks/useMetadata/useMetadata.js

@@ -1,11 +1,11 @@
-import { useMemo } from 'react';
-const metadataStore = new WeakMap();
-export function useMetadata(key) {
-    return useMemo(() => {
-        const getMetadata = () => metadataStore.get(key);
-        const setMetadata = (value) => {
-            metadataStore.set(key, value);
-        };
-        return [getMetadata, setMetadata];
-    }, [key]);
-}
+import { useMemo } from 'react';
+const metadataStore = new WeakMap();
+export function useMetadata(key) {
+    return useMemo(() => {
+        const getMetadata = () => metadataStore.get(key);
+        const setMetadata = (value) => {
+            metadataStore.set(key, value);
+        };
+        return [getMetadata, setMetadata];
+    }, [key]);
+}

package/lib/esm/hooks/useOnKeyDownEffect.d.ts

@@ -1 +1 @@
-export declare function useOnKeyDownEffect(targetKey: KeyboardEvent['key'], isActive: boolean, callback?: () => void): void;
+export declare function useOnKeyDownEffect(targetKey: KeyboardEvent['key'], isActive: boolean, callback?: () => void): void;

package/lib/esm/hooks/useOnKeyDownEffect.js

@@ -1,19 +1,19 @@
-import { useEffect } from 'react';
-export function useOnKeyDownEffect(targetKey, isActive, callback) {
-    useEffect(() => {
-        if (!isActive || !callback) {
-            return () => {
-                // NOOP
-            };
-        }
-        const handleKeyDown = (event) => {
-            if (event.key === targetKey) {
-                callback();
-            }
-        };
-        document.addEventListener('keydown', handleKeyDown);
-        return () => {
-            document.removeEventListener('keydown', handleKeyDown);
-        };
-    }, [targetKey, isActive, callback]);
-}
+import { useEffect } from 'react';
+export function useOnKeyDownEffect(targetKey, isActive, callback) {
+    useEffect(() => {
+        if (!isActive || !callback) {
+            return () => {
+                // NOOP
+            };
+        }
+        const handleKeyDown = (event) => {
+            if (event.key === targetKey) {
+                callback();
+            }
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return () => {
+            document.removeEventListener('keydown', handleKeyDown);
+        };
+    }, [targetKey, isActive, callback]);
+}

package/lib/esm/hooks/useQpq.d.ts

@@ -1,2 +1,2 @@
-import { ActionProcessorListResolver, StoryResolver } from 'quidproquo-core';
-export declare function useQpq(getActionProcessors?: ActionProcessorListResolver): StoryResolver;
+import { ActionProcessorListResolver, StoryResolver } from 'quidproquo-core';
+export declare function useQpq(getActionProcessors?: ActionProcessorListResolver): StoryResolver;

package/lib/esm/hooks/useQpq.js

@@ -1,32 +1,34 @@
-import { getWebActionProcessors } from 'quidproquo-actionprocessor-web';
-import { createRuntime, defineModule, QpqRuntimeType, } from 'quidproquo-core';
-import { useQpqContextValues } from './asmj';
-// WIP ~ useFastCallback, wack things like loggers in a context, try to only make once instance of the runtime.
-// Also don't create every refresh.. useMemo / useCallback etc
-export function useQpq(getActionProcessors = async () => ({})) {
-    const qpqContextValues = useQpqContextValues();
-    const logger = {
-        enableLogs: async () => { },
-        log: async () => { },
-        waitToFinishWriting: async () => { },
-        moveToPermanentStorage: async () => { },
-    };
-    const resolveStory = createRuntime([defineModule('UI')], {
-        depth: 0,
-        context: qpqContextValues,
-    }, async (qpqConfig, dynamicModuleLoader) => ({
-        ...(await getWebActionProcessors(qpqConfig, dynamicModuleLoader)),
-        ...(await getActionProcessors(qpqConfig, dynamicModuleLoader)),
-    }), () => new Date().toISOString(), logger, `frontend::${'uuid'}`, QpqRuntimeType.UI, async (_runtime) => {
-        // noop
-    });
-    return function getStoryExecutor(story) {
-        return async (...args) => {
-            const result = await resolveStory(story, args);
-            if (result.error) {
-                throw new Error(result.error.errorText);
-            }
-            return result.result;
-        };
-    };
-}
+import { getWebActionProcessors } from 'quidproquo-actionprocessor-web';
+import { createRuntime, defineModule, QpqRuntimeType, } from 'quidproquo-core';
+import { useCallback, useMemo } from 'react';
+import { useQpqContextValues } from './asmj';
+// WIP ~ useFastCallback, wack things like loggers in a context, try to only make once instance of the runtime.
+// Also don't create every refresh.. useMemo / useCallback etc
+const logger = {
+    enableLogs: async () => { },
+    log: async () => { },
+    waitToFinishWriting: async () => { },
+    moveToPermanentStorage: async () => { },
+};
+export function useQpq(getActionProcessors = async () => ({})) {
+    const qpqContextValues = useQpqContextValues();
+    const resolveStory = useMemo(() => createRuntime([defineModule('UI')], {
+        depth: 0,
+        context: qpqContextValues,
+    }, async (qpqConfig, dynamicModuleLoader) => ({
+        ...(await getWebActionProcessors(qpqConfig, dynamicModuleLoader)),
+        ...(await getActionProcessors(qpqConfig, dynamicModuleLoader)),
+    }), () => new Date().toISOString(), logger, `frontend::${'uuid'}`, QpqRuntimeType.UI, async (_runtime) => {
+        // noop
+    }), [qpqContextValues]);
+    const qpq = useCallback(function getStoryExecutor(story) {
+        return async (...args) => {
+            const result = await resolveStory(story, args);
+            if (result.error) {
+                throw new Error(result.error.errorText);
+            }
+            return result.result;
+        };
+    }, [resolveStory]);
+    return qpq;
+}

package/lib/esm/hooks/useRunEvery.d.ts

@@ -1 +1 @@
-export declare function useRunEvery<T>(func: () => T, intervalSeconds: number): T;
+export declare function useRunEvery<T>(func: () => T, intervalSeconds: number): T;

package/lib/esm/hooks/useRunEvery.js

@@ -1,18 +1,18 @@
-import { useEffect, useRef, useState } from 'react';
-export function useRunEvery(func, intervalSeconds) {
-    const [value, setValue] = useState(func);
-    const intervalRef = useRef(null);
-    useEffect(() => {
-        intervalRef.current = window.setInterval(() => {
-            const newValue = func();
-            setValue(newValue);
-        }, intervalSeconds * 1000);
-        return () => {
-            if (intervalRef.current !== null) {
-                window.clearInterval(intervalRef.current);
-                intervalRef.current = null;
-            }
-        };
-    }, [intervalSeconds]);
-    return value;
-}
+import { useEffect, useRef, useState } from 'react';
+export function useRunEvery(func, intervalSeconds) {
+    const [value, setValue] = useState(func);
+    const intervalRef = useRef(null);
+    useEffect(() => {
+        intervalRef.current = window.setInterval(() => {
+            const newValue = func();
+            setValue(newValue);
+        }, intervalSeconds * 1000);
+        return () => {
+            if (intervalRef.current !== null) {
+                window.clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+        };
+    }, [intervalSeconds]);
+    return value;
+}

package/lib/esm/hooks/useThrottledMemo.d.ts

@@ -1 +1 @@
-export declare function useThrottledMemo<T>(factory: () => T, deps: any[], delaySeconds?: number): T;
+export declare function useThrottledMemo<T>(factory: () => T, deps: any[], delaySeconds?: number): T;