react-shared-states 1.0.8 → 1.0.11

package/README.md

@@ -1,4 +1,3 @@
-
 # React Shared States
 
 **_Global state made as simple as useState, with zero config, built-in async caching, and automatic scoping._**
@@ -198,16 +197,396 @@ export default function App(){
 
 
 ## 🧠 Core Concepts
-| Concept                | Summary                                                                                                                         |
-|------------------------|---------------------------------------------------------------------------------------------------------------------------------|
-| Global by default      | No provider necessary. Same key => shared state.                                                                                |
-| Scoping                | Wrap with `SharedStatesProvider` to isolate. Nearest provider wins.                                                             |
-| Named scopes           | `scopeName` prop lets distant providers sync (same name ⇒ same bucket). Unnamed providers auto‑generate a random isolated name. |
-| Manual override        | Third param in `useSharedState` / `useSharedFunction` / `useSharedSubscription` enforces a specific scope ignoring tree search. |
-| Shared functions       | Encapsulate async logic: single flight + cached result + `error` + `isLoading` + opt‑in refresh.                                |
-| Shared subscriptions   | Real-time data streams: automatic cleanup + shared connections + `error` + `isLoading` + subscription state.                    |
-| Static APIs            | Access state/functions/subscriptions outside components (`sharedStatesApi`, `sharedFunctionsApi`, `sharedSubscriptionsApi`).    |
-| Static/shared creation | Use `createSharedState`, `createSharedFunction`, `createSharedSubscription` to export reusable, type-safe shared resources.     |
+| Concept                | Summary                                                                                                                                                            |
+|------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Global by default      | No provider necessary. Same key => shared state.                                                                                                                   |
+| Scoping                | Wrap with `SharedStatesProvider` to isolate. Nearest provider wins.                                                                                                |
+| Named scopes           | `scopeName` prop lets distant providers sync (same name ⇒ same bucket). Unnamed providers auto‑generate a random isolated name.                                    |
+| Manual override        | Third param in `useSharedState` / `useSharedFunction` / `useSharedSubscription` enforces a specific scope ignoring tree search.                                    |
+| Shared functions       | Encapsulate async logic: single flight + cached result + `error` + `isLoading` + opt‑in refresh.                                                                   |
+| Shared subscriptions   | Real-time data streams: automatic cleanup + shared connections + `error` + `isLoading` + subscription state.                                                       |
+| Static APIs            | Access state/functions/subscriptions outside components (`sharedStatesApi`, `sharedFunctionsApi`, `sharedSubscriptionsApi`).                                       |
+| Static/shared creation | Use `createSharedState`, `createSharedFunction`, `createSharedSubscription` to export reusable, type-safe shared resources that persist across `clearAll()` calls. |
+
+
+## 🏗️ Sharing State (`useSharedState`)
+Signature: 
+- `const [value, setValue] = useSharedState(key, initialValue, scopeName?)`
+- `const [value, setValue] = useSharedState(sharedStateCreated)`
+
+Behavior:
+* First hook call (per key + scope) seeds with `initialValue`.
+* Subsequent mounts with same key+scope ignore their `initialValue` (consistent source of truth).
+* Setter accepts either value or updater `(prev)=>next`.
+* React batching + equality check: listeners fire only when the value reference actually changes.
+* States created with `createSharedState` are **static** by default and are not removed by `clear()` or `clearAll()`, ensuring they persist.
+
+### Examples
+1. Global theme (recommended for large apps)
+    ```tsx
+    // themeState.ts
+    export const themeState = createSharedState('light');
+    // In components
+    const [theme, setTheme] = useSharedState(themeState);
+    ```
+2. Isolated wizard progress
+    ```tsx
+    const wizardProgress = createSharedState(0);
+    <SharedStatesProvider>
+      <Wizard/>
+    </SharedStatesProvider>
+    // In Wizard
+    const [step, setStep] = useSharedState(wizardProgress);
+    ```
+3. Forcing cross‑portal sync
+    ```tsx
+    const navState = createSharedState('closed', 'nav');
+    <SharedStatesProvider scopeName="nav" children={<PrimaryNav/>} />
+    <Portal>
+      <SharedStatesProvider scopeName="nav" children={<MobileNav/>} />
+    </Portal>
+    // In both navs
+    const [navOpen, setNavOpen] = useSharedState(navState);
+    ```
+4. Overriding nearest provider
+    ```tsx
+    // Even if inside a provider, this explicitly binds to global
+    const globalFlag = createSharedState(false, '_global');
+    const [flag, setFlag] = useSharedState(globalFlag);
+    ```
+
+
+## ⚡ Shared Async Functions (`useSharedFunction`)
+Signature:
+- `const { state, trigger, forceTrigger, clear } = useSharedFunction(key, asyncFn, scopeName?)`
+- `const { state, trigger, forceTrigger, clear } = useSharedFunction(sharedFunctionCreated)`
+`state` shape: `{ results?: T; isLoading: boolean; error?: unknown }`
+
+Semantics:
+* First `trigger()` (implicit or manual) runs the function; subsequent calls do nothing while loading or after success (cached) unless you `forceTrigger()`.
+* Multiple components with the same key+scope share one execution + result.
+* `clear()` deletes the cache (next trigger re-runs).
+* You decide when to invoke `trigger` (e.g. on mount, on button click, when dependencies change, etc.).
+* Functions created with `createSharedFunction` are **static** and persist across `clearAll()` calls.
+
+### Pattern: lazy load on first render
+```tsx
+// profileFunction.ts
+export const profileFunction = createSharedFunction((id: string) => fetch(`/api/p/${id}`).then(r=>r.json()));
+
+function Profile({id}:{id:string}){
+  const { state, trigger } = useSharedFunction(profileFunction);
+  // ...same as before
+}
+```
+
+### Pattern: always fetch fresh
+```tsx
+const { state, forceTrigger } = useSharedFunction('server-time', () => fetch('/time').then(r=>r.text()));
+const refresh = () => forceTrigger();
+```
+
+
+## 📡 Real-time Subscriptions (`useSharedSubscription`)
+Perfect for Firebase listeners, WebSocket connections,
+Server-Sent Events, or any streaming data source that needs cleanup.
+
+Signature:
+- `const { state, trigger, unsubscribe } = useSharedSubscription(key, subscriber, scopeName?)`
+- `const { state, trigger, unsubscribe } = useSharedSubscription(sharedSubscriptionCreated)`
+
+`state` shape: `{ data?: T; isLoading: boolean; error?: unknown; subscribed: boolean }`
+
+The `subscriber` function receives three callbacks:
+- `set(data)`: Update the shared data
+- `error(error)`: Handle errors 
+- `complete()`: Mark loading as complete
+- Returns: Optional cleanup function (called on unsubscribe/unmount)
+
+### Pattern: Firebase Firestore real-time listener
+```tsx
+// userSubscription.ts
+import { onSnapshot, doc } from 'firebase/firestore';
+import { createSharedSubscription } from 'react-shared-states';
+import { db } from './firebase-config';
+
+export const userSubscription = createSharedSubscription(
+  (set, error, complete) => {
+    const userDocRef = doc(db, 'users', 'some-user-id');
+    const unsubscribe = onSnapshot(userDocRef, 
+      (doc) => {
+        if (doc.exists()) {
+          set(doc.data());
+        } else {
+          error(new Error('User not found'));
+        }
+        complete();
+      }, 
+      (err) => {
+        error(err);
+        complete();
+      }
+    );
+    return unsubscribe;
+  }
+);
+
+function UserProfile({ userId }: { userId: string }) {
+  const { state, trigger, unsubscribe } = useSharedSubscription(userSubscription);
+  // Start listening when component mounts
+  useEffect(() => {
+    trigger();
+  }, []);
+
+  if (state.isLoading) return <div>Connecting...</div>;
+  if (state.error) return <div>Error: {state.error.message}</div>;
+  if (!state.data) return <div>User not found</div>;
+
+  return (
+    <div>
+      <h1>{state.data.name}</h1>
+      <p>{state.data.email}</p>
+      <button onClick={unsubscribe}>Stop listening</button>
+    </div>
+  );
+}
+```
+
+### Pattern: WebSocket connection
+```tsx
+import { useEffect } from 'react';
+import { useSharedSubscription } from 'react-shared-states';
+
+function ChatRoom({ roomId }: { roomId: string }) {
+  const { state, trigger } = useSharedSubscription(
+    `chat-${roomId}`,
+    (set, error, complete) => {
+      const ws = new WebSocket(`ws://chat-server/${roomId}`);
+      
+      ws.onopen = () => complete();
+      ws.onmessage = (event) => {
+        const message = JSON.parse(event.data);
+        set(prev => [...(prev || []), message]);
+      };
+      ws.onerror = error;
+      
+      return () => ws.close();
+    }
+  );
+
+  useEffect(() => {
+    trigger();
+  }, []);
+
+  return (
+    <div>
+      {state.isLoading && <p>Connecting to chat...</p>}
+      {state.error && <p>Connection failed</p>}
+      <div>
+        {state.data?.map(msg => (
+          <div key={msg.id}>{msg.text}</div>
+        ))}
+      </div>
+    </div>
+  );
+}
+```
+
+### Pattern: Server-Sent Events
+```tsx
+import { useEffect } from 'react';
+import { useSharedSubscription } from 'react-shared-states';
+
+function LiveUpdates() {
+  const { state, trigger } = useSharedSubscription(
+    'live-updates',
+    (set, error, complete) => {
+      const eventSource = new EventSource('/api/live-updates');
+      
+      eventSource.onopen = () => complete();
+      eventSource.onmessage = (event) => {
+        set(JSON.parse(event.data));
+      };
+      eventSource.onerror = error;
+      
+      return () => eventSource.close();
+    }
+  );
+
+  useEffect(() => {
+    trigger();
+  }, []);
+
+  return <div>Latest: {JSON.stringify(state.data)}</div>;
+}
+```
+
+Subscription semantics:
+* First `trigger()` establishes the subscription; subsequent calls do nothing if already subscribed.
+* Multiple components with the same key+scope share one subscription + data stream.
+* `unsubscribe()` closes the connection and clears the subscribed state.
+* Automatic cleanup on component unmount when no other components are listening.
+* Components mounting later instantly get the latest `data` without re-subscribing.
+
+
+## 🛰️ Static APIs (outside React)
+## 🏛️ Static/Global Shared Resource Creation
+
+For large apps, you can create and export shared state, function,
+or subscription objects for type safety and to avoid key collisions.
+This pattern is similar to Zustand or Jotai stores:
+
+```ts
+import { createSharedState, createSharedFunction, createSharedSubscription, useSharedState, useSharedFunction, useSharedSubscription } from 'react-shared-states';
+
+// Create and export shared resources
+export const counterState = createSharedState(0);
+export const fetchUserFunction = createSharedFunction(() => fetch('/api/me').then(r => r.json()));
+export const chatSubscription = createSharedSubscription((set, error, complete) => {/* ... */});
+
+// Use anywhere in your app
+const [count, setCount] = useSharedState(counterState);
+const { state, trigger } = useSharedFunction(fetchUserFunction);
+const { state, trigger, unsubscribe } = useSharedSubscription(chatSubscription);
+```
+Useful for SSR hydration, event listeners, debugging, imperative workflows.
+
+```ts
+import { sharedStatesApi, sharedFunctionsApi, sharedSubscriptionsApi } from 'react-shared-states';
+
+// Preload state (global scope by default)
+sharedStatesApi.set('bootstrap-data', { user: {...} });
+
+// Preload state in a named scope
+sharedStatesApi.set('bootstrap-data', { user: {...} }, 'myScope');
+
+// Read later
+const user = sharedStatesApi.get('bootstrap-data'); // global
+const userScoped = sharedStatesApi.get('bootstrap-data', 'myScope');
+
+// Inspect all (returns nested object: { [scope]: { [key]: value } })
+console.log(sharedStatesApi.getAll());
+
+// Clear all keys in a scope
+sharedStatesApi.clearScope('myScope');
+
+// For shared functions
+const fnState = sharedFunctionsApi.get('profile-123');
+const fnStateScoped = sharedFunctionsApi.get('profile-123', 'myScope');
+
+// For shared subscriptions
+const subState = sharedSubscriptionsApi.get('live-chat');
+const subStateScoped = sharedSubscriptionsApi.get('live-chat', 'myScope');
+```
+
+## API summary:
+
+| API                      | Methods                                                                                                                                                                                 |
+|--------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `sharedStatesApi`        | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
+| `sharedFunctionsApi`     | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
+| `sharedSubscriptionsApi` | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
+
+`scopeName` defaults to `"_global"`. Internally, keys are stored as `${scope}//${key}`. The `.getAll()` method returns a nested object: `{ [scope]: { [key]: value } }`.
+
+
+## 🧩 Scoping Rules Deep Dive
+Resolution order used inside hooks:
+1. Explicit 3rd parameter (`scopeName`)
+2. Nearest `SharedStatesProvider` above the component
+3. The implicit global scope (`_global`)
+
+Unnamed providers auto‑generate a random scope name: each mount = isolated island.
+
+Two providers sharing the same `scopeName` act as a single logical scope even if they are disjoint in the tree (great for portals / microfrontends).
+
+
+## 🆚 Comparison Snapshot
+| Criterion      | react-shared-states                      | Redux Toolkit        | Zustand                          |
+|----------------|------------------------------------------|----------------------|----------------------------------|
+| Setup          | Install & call hook                      | Slice + store config | Create store function            |
+| Global state   | Yes (by key)                             | Yes                  | Yes                              |
+| Scoped state   | Built-in (providers + names + overrides) | Needs custom logic   | Needs multiple stores / contexts |
+| Async helper   | `useSharedFunction` (cache + status)     | Thunks / RTK Query   | Manual or middleware             |
+| Boilerplate    | Near zero                                | Moderate             | Low                              |
+| Static access  | Yes (APIs)                               | Yes (store)          | Yes (store)                      |
+| Learning curve | Minutes                                  | Higher               | Low                              |
+
+
+## 🧪 Testing Tips
+* Use static APIs to assert state after component interactions.
+* `sharedStatesApi.clearAll(false, true)`, `sharedFunctionsApi.clearAll(false, true)`, `sharedSubscriptionsApi.clearAll(false, true)` in `afterEach` to isolate tests and clear static states.
+* For async functions: trigger once, await UI stabilization, assert `results` present.
+* For subscriptions: mock the subscription source (Firebase, WebSocket, etc.) and verify data flow.
+
+
+## ❓ FAQ
+**Q: How do I reset a single shared state?**  
+`sharedStatesApi.clear('key')`. If the state was created with `createSharedState`, it will reset to its initial value. Otherwise, it will be removed.
+
+**Q: Can I pre-hydrate data on the server?**  
+Yes. Call `sharedStatesApi.set(...)` during bootstrap, then first client hook usage will pick it up.
+
+**Q: How do I avoid accidental key collisions?**  
+Prefix keys by domain (e.g. `user:profile`, `cart:items`) or rely on provider scoping.
+
+**Q: Why is my async function not re-running?**  
+It's cached. Use `forceTrigger()` or `clear()`.
+
+**Q: How do I handle subscription cleanup?**  
+Subscriptions auto-cleanup when no components are listening. You can also manually call `unsubscribe()`.
+
+**Q: Can I use it with Suspense?**  
+Currently no built-in Suspense wrappers; wrap `useSharedFunction` yourself if desired.
+
+
+## 📚 Full API Reference
+### `useSharedState(key, initialValue, scopeName?)`
+Returns `[value, setValue]`.
+
+### `useSharedState(sharedStateCreated)`
+Returns `[value, setValue]`.
+
+### `useSharedFunction(key, fn, scopeName?)`
+Returns `{ state, trigger, forceTrigger, clear }`.
+
+### `useSharedFunction(sharedFunctionCreated)`
+Returns `{ state, trigger, forceTrigger, clear }`.
+
+### `useSharedSubscription(key, subscriber, scopeName?)`
+Returns `{ state, trigger, unsubscribe }`.
+
+### `useSharedSubscription(sharedSubscriptionCreated)`
+Returns `{ state, trigger, unsubscribe }`.
+
+### `<SharedStatesProvider scopeName?>`
+Wrap children; optional `scopeName` (string). If omitted a random unique one is generated.
+
+### Static APIs
+`sharedStatesApi`, `sharedFunctionsApi`, `sharedSubscriptionsApi` (see earlier table).
+
+
+
+## 🤝 Contributions
+
+We welcome contributions!
+If you'd like to improve `react-shared-states`,
+feel free to [open an issue](https://github.com/HichemTab-tech/react-shared-states/issues) or [submit a pull request](https://github.com/HichemTab-tech/react-shared-states/pulls).
+
+
+## Author
+
+- [@HichemTab-tech](https://www.github.com/HichemTab-tech)
+
+## License
+
+[MIT](https://github.com/HichemTab-tech/react-shared-states/blob/master/LICENSE)
+
+## 🌟 Acknowledgements
+
+Inspired by React's built-in primitives and the ergonomics of modern lightweight state libraries.
+Thanks to early adopters for feedback.
+
 
 
 ## 🏗️ Sharing State (`useSharedState`)
@@ -298,8 +677,8 @@ Signature:
 
 The `subscriber` function receives three callbacks:
 - `set(data)`: Update the shared data
-- `onError(error)`: Handle errors 
-- `onCompletion()`: Mark loading as complete
+- `error(error)`: Handle errors 
+- `complete()`: Mark loading as complete
 - Returns: Optional cleanup function (called on unsubscribe/unmount)
 
 ### Pattern: Firebase Firestore real-time listener
@@ -310,8 +689,23 @@ import { createSharedSubscription } from 'react-shared-states';
 import { db } from './firebase-config';
 
 export const userSubscription = createSharedSubscription(
-  async (set, onError, onCompletion) => {
-    // ...same as before
+  (set, error, complete) => {
+    const userDocRef = doc(db, 'users', 'some-user-id');
+    const unsubscribe = onSnapshot(userDocRef, 
+      (doc) => {
+        if (doc.exists()) {
+          set(doc.data());
+        } else {
+          error(new Error('User not found'));
+        }
+        complete();
+      }, 
+      (err) => {
+        error(err);
+        complete();
+      }
+    );
+    return unsubscribe;
   }
 );
 
@@ -344,15 +738,15 @@ import { useSharedSubscription } from 'react-shared-states';
 function ChatRoom({ roomId }: { roomId: string }) {
   const { state, trigger } = useSharedSubscription(
     `chat-${roomId}`,
-    (set, onError, onCompletion) => {
+    (set, error, complete) => {
       const ws = new WebSocket(`ws://chat-server/${roomId}`);
       
-      ws.onopen = () => onCompletion();
+      ws.onopen = () => complete();
       ws.onmessage = (event) => {
         const message = JSON.parse(event.data);
         set(prev => [...(prev || []), message]);
       };
-      ws.onerror = onError;
+      ws.onerror = error;
       
       return () => ws.close();
     }
@@ -384,14 +778,14 @@ import { useSharedSubscription } from 'react-shared-states';
 function LiveUpdates() {
   const { state, trigger } = useSharedSubscription(
     'live-updates',
-    (set, onError, onCompletion) => {
+    (set, error, complete) => {
       const eventSource = new EventSource('/api/live-updates');
       
-      eventSource.onopen = () => onCompletion();
+      eventSource.onopen = () => complete();
       eventSource.onmessage = (event) => {
         set(JSON.parse(event.data));
       };
-      eventSource.onerror = onError;
+      eventSource.onerror = error;
       
       return () => eventSource.close();
     }
@@ -424,7 +818,7 @@ import { createSharedState, createSharedFunction, createSharedSubscription, useS
 // Create and export shared resources
 export const counterState = createSharedState(0);
 export const fetchUserFunction = createSharedFunction(() => fetch('/api/me').then(r => r.json()));
-export const chatSubscription = createSharedSubscription((set, onError, onCompletion) => {/* ... */});
+export const chatSubscription = createSharedSubscription((set, error, complete) => {/* ... */});
 
 // Use anywhere in your app
 const [count, setCount] = useSharedState(counterState);
@@ -463,11 +857,11 @@ const subStateScoped = sharedSubscriptionsApi.get('live-chat', 'myScope');
 
 ## API summary:
 
-| API                      | Methods                                                                                                                                                   |
-|--------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------|
-| `sharedStatesApi`        | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll()`, `clearScope(scopeName?)`, `getAll()` |
-| `sharedFunctionsApi`     | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll()`, `clearScope(scopeName?)`, `getAll()` |
-| `sharedSubscriptionsApi` | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll()`, `clearScope(scopeName?)`, `getAll()` |
+| API                      | Methods                                                                                                                                                                                 |
+|--------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `sharedStatesApi`        | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
+| `sharedFunctionsApi`     | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
+| `sharedSubscriptionsApi` | `get(key, scopeName?)`, `set(key, val, scopeName?)`, `has(key, scopeName?)`, `clear(key, scopeName?)`, `clearAll(withoutListeners?, withStatic?)`, `clearScope(scopeName?)`, `getAll()` |
 
 `scopeName` defaults to `"_global"`. Internally, keys are stored as `${scope}//${key}`. The `.getAll()` method returns a nested object: `{ [scope]: { [key]: value } }`.
 
@@ -497,14 +891,15 @@ Two providers sharing the same `scopeName` act as a single logical scope even if
 
 ## 🧪 Testing Tips
 * Use static APIs to assert state after component interactions.
-* `sharedStatesApi.clearAll()`, `sharedFunctionsApi.clearAll()`, `sharedSubscriptionsApi.clearAll()` in `afterEach` to isolate tests.
+* `sharedStatesApi.clearAll(false, true)`, `sharedFunctionsApi.clearAll(false, true)`, `sharedSubscriptionsApi.clearAll(false, true)` in `afterEach` to isolate tests and clear static states.
 * For async functions: trigger once, await UI stabilization, assert `results` present.
 * For subscriptions: mock the subscription source (Firebase, WebSocket, etc.) and verify data flow.
 
 
 ## ❓ FAQ
 **Q: How do I reset a single shared state?**  
-`sharedStatesApi.clear('key')` or inside component: call a setter with the initial value.
+`sharedStatesApi.clear('key')`. If the state was created with `createSharedState`, it will reset to its initial value.
+Otherwise, it will be removed.
 
 **Q: Can I pre-hydrate data on the server?**  
 Yes. Call `sharedStatesApi.set(...)` during bootstrap, then first client hook usage will pick it up.

package/dist/{SharedData.d.ts → SharedValuesManager.d.ts}

@@ -1,37 +1,44 @@
-import { AFunction, DataMapValue, Prefix, SharedCreated } from './types';
-type SharedDataType<T> = DataMapValue & T;
-export declare abstract class SharedData<T> {
-    data: Map<string, SharedDataType<T>>;
-    defaultValue(): T;
+import { AFunction, Prefix, SharedCreated, SharedValue } from './types';
+export declare const staticStores: SharedCreated[];
+export declare abstract class SharedValuesManager<T extends SharedValue, V> {
+    data: Map<string, T>;
+    defaultValue(): V;
     addListener(key: string, prefix: Prefix, listener: AFunction): void;
     removeListener(key: string, prefix: Prefix, listener: AFunction): void;
     callListeners(key: string, prefix: Prefix): void;
-    init(key: string, prefix: Prefix, data: T): void;
-    clearAll(withoutListeners?: boolean): void;
-    clear(key: string, prefix: Prefix, withoutListeners?: boolean): void;
-    get(key: string, prefix: Prefix): SharedDataType<T> | undefined;
-    setValue(key: string, prefix: Prefix, data: T): void;
+    init(key: string, prefix: Prefix, data: V, isStatic?: boolean): void;
+    createStatic<X extends SharedCreated>(rest: Omit<X, 'key' | 'prefix'>, scopeName?: Prefix): {
+        key: string;
+        prefix: Prefix;
+    } & Omit<X, "key" | "prefix">;
+    initStatic(sharedCreated: SharedCreated): void;
+    clearAll(withoutListeners?: boolean, withStatic?: boolean): void;
+    clear(key: string, prefix: Prefix, withoutListeners?: boolean, withStatic?: boolean): void;
+    get(key: string, prefix: Prefix): T | undefined;
+    setValue(key: string, prefix: Prefix, data: V): void;
     has(key: string, prefix: Prefix): string | undefined;
     static prefix(key: string, prefix: Prefix): string;
     static extractPrefix(mapKey: string): string[];
     useEffect(key: string, prefix: Prefix, unsub?: (() => void) | null): void;
 }
-export declare class SharedApi<T> {
-    private sharedData;
-    constructor(sharedData: SharedData<T>);
+export declare class SharedValuesApi<T extends SharedValue, V, R = T> {
+    protected sharedData: SharedValuesManager<T, V>;
+    constructor(sharedData: SharedValuesManager<T, V>);
     /**
      * get a value from the shared data
      * @param key
      * @param scopeName
      */
-    get<S extends string = string>(key: S, scopeName: Prefix): T;
+    get<S extends string = string>(key: S, scopeName: Prefix): R;
+    get<S extends string = string>(sharedCreated: SharedCreated): R;
     /**
      * set a value in the shared data
      * @param key
      * @param value
      * @param scopeName
      */
-    set<S extends string = string>(key: S, value: T, scopeName: Prefix): void;
+    set<S extends string = string>(key: S, value: V, scopeName: Prefix): void;
+    set<S extends string = string>(sharedCreated: SharedCreated, value: V): void;
     /**
      * clear all values from the shared data
      */
@@ -45,7 +52,12 @@ export declare class SharedApi<T> {
      * resolve a shared created object to a value
      * @param sharedCreated
      */
-    resolve(sharedCreated: SharedCreated): T;
+    resolve(sharedCreated: SharedCreated): R;
+    /**
+     * clear a value from the shared data
+     * @param key
+     * @param scopeName
+     */
     clear(key: string, scopeName: Prefix): void;
     clear(sharedCreated: SharedCreated): void;
     /**
@@ -59,4 +71,3 @@ export declare class SharedApi<T> {
      */
     getAll(): Record<string, Record<string, any>>;
 }
-export {};

package/dist/hooks/use-shared-function.d.ts

@@ -1,15 +1,40 @@
-import { AFunction, Prefix, SharedCreated } from '../types';
-import { SharedApi } from '../SharedData';
-type SharedFunctionsState<T> = {
-    fnState: {
-        results?: T;
-        isLoading: boolean;
-        error?: unknown;
-    };
+import { AFunction, Prefix, SharedCreated, SharedValue } from '../types';
+import { SharedValuesApi, SharedValuesManager } from '../SharedValuesManager';
+type SharedFunctionValue<T> = {
+    results?: T;
+    isLoading: boolean;
+    error?: unknown;
 };
-export declare class SharedFunctionsApi extends SharedApi<SharedFunctionsState<unknown>> {
-    get<T, S extends string = string>(key: S, scopeName?: Prefix): T;
-    set<T, S extends string = string>(key: S, fnState: SharedFunctionsState<T>, scopeName?: Prefix): void;
+interface SharedFunction<T> extends SharedValue {
+    fnState: SharedFunctionValue<T>;
+}
+declare class SharedFunctionsManager extends SharedValuesManager<SharedFunction<unknown>, {
+    fnState: SharedFunctionValue<unknown>;
+}> {
+    defaultValue(): {
+        fnState: {
+            results: undefined;
+            isLoading: boolean;
+            error: undefined;
+        };
+    };
+    initValue(key: string, prefix: Prefix, isStatic?: boolean): void;
+    setValue<T>(key: string, prefix: Prefix, data: {
+        fnState: SharedFunctionValue<T>;
+    }): void;
+}
+export declare class SharedFunctionsApi extends SharedValuesApi<SharedFunction<unknown>, {
+    fnState: SharedFunctionValue<unknown>;
+}, SharedFunctionValue<unknown>> {
+    constructor(sharedFunctionManager: SharedFunctionsManager);
+    get<T, S extends string = string>(key: S, scopeName?: Prefix): SharedFunctionValue<T>;
+    get<T, Args extends unknown[]>(sharedFunctionCreated: SharedFunctionCreated<T, Args>): SharedFunctionValue<T>;
+    set<T, S extends string = string>(key: S, value: {
+        fnState: SharedFunctionValue<T>;
+    }, scopeName?: Prefix): void;
+    set<T, Args extends unknown[]>(sharedFunctionCreated: SharedFunctionCreated<T, Args>, value: {
+        fnState: SharedFunctionValue<T>;
+    }): void;
 }
 export declare const sharedFunctionsApi: SharedFunctionsApi;
 interface SharedFunctionCreated<T, Args extends unknown[]> extends SharedCreated {
@@ -17,7 +42,7 @@ interface SharedFunctionCreated<T, Args extends unknown[]> extends SharedCreated
 }
 export declare const createSharedFunction: <T, Args extends unknown[]>(fn: AFunction<T, Args>, scopeName?: Prefix) => SharedFunctionCreated<T, Args>;
 export type SharedFunctionStateReturn<T, Args extends unknown[]> = {
-    readonly state: NonNullable<SharedFunctionsState<T>['fnState']>;
+    readonly state: NonNullable<SharedFunctionValue<T>>;
     readonly trigger: (...args: Args) => void;
     readonly forceTrigger: (...args: Args) => void;
     readonly clear: () => void;