react-shared-states 1.0.7 → 1.0.11

package/dist/SharedValuesManager.d.ts

@@ -0,0 +1,73 @@
+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: 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 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): 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: V, scopeName: Prefix): void;
+    set<S extends string = string>(sharedCreated: SharedCreated, value: V): void;
+    /**
+     * clear all values from the shared data
+     */
+    clearAll(): void;
+    /**
+     * clear all values from the shared data in a scope
+     * @param scopeName
+     */
+    clearScope(scopeName?: Prefix): void;
+    /**
+     * resolve a shared created object to a value
+     * @param sharedCreated
+     */
+    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;
+    /**
+     * check if a value exists in the shared data
+     * @param key
+     * @param scopeName
+     */
+    has(key: string, scopeName?: Prefix): boolean;
+    /**
+     * get all values from the shared data
+     */
+    getAll(): Record<string, Record<string, any>>;
+}

package/dist/context/SharedStatesContext.d.ts

@@ -1,11 +1,12 @@
 import { PropsWithChildren } from 'react';
-import { NonEmptyString } from '../types';
+import { Prefix } from '../types';
 export interface SharedStatesType {
     scopeName: string;
 }
-interface SharedStatesProviderProps<T extends string = string> extends PropsWithChildren {
-    scopeName?: '__global' extends NonEmptyString<T> ? never : NonEmptyString<T>;
+export declare const SharedStatesContext: import('react').Context<SharedStatesType | undefined>;
+interface SharedStatesProviderProps extends PropsWithChildren {
+    scopeName?: Prefix;
 }
-export declare const SharedStatesProvider: <T extends string = string>({ children, scopeName }: SharedStatesProviderProps<T>) => import("react/jsx-runtime").JSX.Element;
+export declare const SharedStatesProvider: ({ children, scopeName }: SharedStatesProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useSharedStatesContext: () => SharedStatesType | undefined;
 export {};

package/dist/hooks/index.d.ts

@@ -1,3 +1,6 @@
-export { useSharedState, sharedStatesApi } from './use-shared-state';
-export { useSharedFunction, sharedFunctionsApi } from './use-shared-function';
-export { useSharedSubscription, sharedSubscriptionsApi } from './use-shared-subscription';
+export { useSharedState, sharedStatesApi, createSharedState, SharedStatesApi } from './use-shared-state';
+export type { SharedStateCreated } from './use-shared-state';
+export { useSharedFunction, sharedFunctionsApi, createSharedFunction, SharedFunctionsApi } from './use-shared-function';
+export type { SharedFunctionStateReturn } from './use-shared-function';
+export { useSharedSubscription, sharedSubscriptionsApi, createSharedSubscription, SharedSubscriptionsApi } from './use-shared-subscription';
+export type { SharedSubscriptionStateReturn } from './use-shared-subscription';

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

@@ -1,25 +1,52 @@
-import { AFunction, Prefix } 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>;
 }
-export declare const sharedFunctionsApi: SharedFunctionsApi;
-export declare const useSharedFunction: <T, Args extends unknown[], S extends string = string>(key: S, fn: AFunction<T, Args>, scopeName?: Prefix) => {
-    readonly state: {
-        results?: T | undefined;
-        isLoading: boolean;
-        error?: unknown;
+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 {
+    fn: AFunction<T, Args>;
+}
+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<SharedFunctionValue<T>>;
     readonly trigger: (...args: Args) => void;
     readonly forceTrigger: (...args: Args) => void;
     readonly clear: () => void;
 };
+export declare function useSharedFunction<T, Args extends unknown[], S extends string = string>(key: S, fn: AFunction<T, Args>, scopeName?: Prefix): SharedFunctionStateReturn<T, Args>;
+export declare function useSharedFunction<T, Args extends unknown[]>(sharedFunctionCreated: SharedFunctionCreated<T, Args>): SharedFunctionStateReturn<T, Args>;
 export {};

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

@@ -1,11 +1,31 @@
-import { Prefix } from '../types';
-import { SharedApi } from '../SharedData';
-declare class SharedStatesApi extends SharedApi<{
+import { Prefix, SharedCreated, SharedValue } from '../types';
+import { SharedValuesApi, SharedValuesManager } from '../SharedValuesManager';
+interface SharedState<T> extends SharedValue {
+    value: T;
+}
+declare class SharedStatesManager extends SharedValuesManager<SharedState<unknown>, {
     value: unknown;
 }> {
+    defaultValue(): {
+        value: undefined;
+    };
+    initValue(key: string, prefix: Prefix, value: unknown, isStatic?: boolean): void;
+    initStatic(sharedStateCreated: SharedStateCreated<any>): void;
+}
+export declare class SharedStatesApi extends SharedValuesApi<SharedState<unknown>, {
+    value: unknown;
+}, unknown> {
+    constructor(sharedStateManager: SharedStatesManager);
     get<T, S extends string = string>(key: S, scopeName?: Prefix): T;
+    get<T>(sharedStateCreated: SharedStateCreated<T>): T;
     set<T, S extends string = string>(key: S, value: T, scopeName?: Prefix): void;
+    set<T>(sharedStateCreated: SharedStateCreated<T>, value: T): void;
 }
 export declare const sharedStatesApi: SharedStatesApi;
-export declare const useSharedState: <T, S extends string = string>(key: S, value: T, scopeName?: Prefix) => readonly [T, (newValueOrCallbackToNewValue: T | ((prev: T) => T)) => void];
+export interface SharedStateCreated<T> extends SharedCreated {
+    initialValue: T;
+}
+export declare const createSharedState: <T>(initialValue: T, scopeName?: Prefix) => SharedStateCreated<T>;
+export declare function useSharedState<T, S extends string>(key: S, initialValue: T, scopeName?: Prefix): readonly [T, (v: T | ((prev: T) => T)) => void];
+export declare function useSharedState<T>(sharedStateCreated: SharedStateCreated<T>): readonly [T, (v: T | ((prev: T) => T)) => void];
 export {};

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

@@ -1,35 +1,64 @@
-import { PotentialPromise, Prefix } from '../types';
-import { SharedApi } from '../SharedData';
-type Unsubscribe = () => void;
+import { PotentialPromise, Prefix, SharedCreated, SharedValue } from '../types';
+import { SharedValuesApi, SharedValuesManager } from '../SharedValuesManager';
+export type Unsubscribe = () => void;
 export declare namespace SubscriberEvents {
     type OnError = (error: unknown) => void;
     type OnCompletion = () => void;
     type Set<T> = (value: T) => void;
 }
-type Subscriber<T> = (set: SubscriberEvents.Set<T>, onError: SubscriberEvents.OnError, onCompletion: SubscriberEvents.OnCompletion) => PotentialPromise<Unsubscribe | void | undefined>;
-type SharedSubscriptionsState<T> = {
-    fnState: {
-        data?: T;
-        isLoading: boolean;
-        error?: unknown;
-        subscribed: boolean;
-    };
-    unsubscribe?: Unsubscribe | void;
+export type Subscriber<T> = (set: SubscriberEvents.Set<T>, onError: SubscriberEvents.OnError, onCompletion: SubscriberEvents.OnCompletion) => PotentialPromise<Unsubscribe | void | undefined>;
+type SharedSubscriptionValue<T> = {
+    data?: T;
+    isLoading: boolean;
+    error?: unknown;
+    subscribed?: boolean;
 };
-export declare class SharedSubscriptionsApi extends SharedApi<SharedSubscriptionsState<unknown>> {
-    get<T, S extends string = string>(key: S, scopeName?: Prefix): T;
-    set<T, S extends string = string>(key: S, fnState: SharedSubscriptionsState<T>, scopeName?: Prefix): void;
+interface SharedSubscription<T> extends SharedValue {
+    fnState: SharedSubscriptionValue<T>;
+    unsubscribe?: Unsubscribe | void;
 }
-export declare const sharedSubscriptionsApi: SharedSubscriptionsApi;
-export declare const useSharedSubscription: <T, S extends string = string>(key: S, subscriber: Subscriber<T>, scopeName?: Prefix) => {
-    readonly state: {
-        data?: T | undefined;
-        isLoading: boolean;
-        error?: unknown;
-        subscribed: boolean;
+declare class SharedSubscriptionsManager extends SharedValuesManager<SharedSubscription<unknown>, {
+    fnState: SharedSubscriptionValue<unknown>;
+}> {
+    defaultValue(): {
+        fnState: {
+            data: undefined;
+            isLoading: boolean;
+            error: undefined;
+            subscribed: boolean;
+        };
     };
+    initValue(key: string, prefix: Prefix, isStatic?: boolean): void;
+    setValue<T>(key: string, prefix: Prefix, data: {
+        fnState: SharedSubscriptionValue<T>;
+    }): void;
+    useEffect(key: string, prefix: Prefix): void;
+    unsubscribe(key: string, prefix: Prefix): Promise<void>;
+}
+export declare class SharedSubscriptionsApi extends SharedValuesApi<SharedSubscription<unknown>, {
+    fnState: SharedSubscriptionValue<unknown>;
+}, SharedSubscriptionValue<unknown>> {
+    constructor(sharedSubscriptionsManager: SharedSubscriptionsManager);
+    get<T, S extends string = string>(key: S, scopeName?: Prefix): SharedSubscriptionValue<T>;
+    get<T>(sharedSubscriptionCreated: SharedSubscriptionCreated<T>): SharedSubscriptionValue<T>;
+    set<T, S extends string = string>(key: S, value: {
+        fnState: SharedSubscriptionValue<T>;
+    }, scopeName?: Prefix): void;
+    set<T>(sharedSubscriptionCreated: SharedSubscriptionCreated<T>, value: {
+        fnState: SharedSubscriptionValue<T>;
+    }): void;
+}
+export declare const sharedSubscriptionsApi: SharedSubscriptionsApi;
+interface SharedSubscriptionCreated<T> extends SharedCreated {
+    subscriber: Subscriber<T>;
+}
+export declare const createSharedSubscription: <T, Args extends unknown[]>(subscriber: Subscriber<T>, scopeName?: Prefix) => SharedSubscriptionCreated<T>;
+export type SharedSubscriptionStateReturn<T> = {
+    readonly state: NonNullable<SharedSubscriptionValue<T>>;
     readonly trigger: () => void;
     readonly forceTrigger: () => void;
     readonly unsubscribe: () => void;
 };
+export declare function useSharedSubscription<T, S extends string = string>(key: S, subscriber: Subscriber<T>, scopeName?: Prefix): SharedSubscriptionStateReturn<T>;
+export declare function useSharedSubscription<T>(sharedSubscriptionCreated: SharedSubscriptionCreated<T>): SharedSubscriptionStateReturn<T>;
 export {};

package/dist/lib/utils.d.ts

@@ -1,3 +1,3 @@
-import { NonEmptyString } from '../types';
 export declare const log: (...args: any[]) => void;
-export declare const ensureNonEmptyString: <T extends string>(value: T) => NonEmptyString<T>;
+export declare const ensureNonEmptyString: <X extends string>(value: X) => X;
+export declare const random: () => string;