@streamlayer/sdk-web-core 0.0.1

package/README.md

@@ -0,0 +1,6 @@
+# core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+Run `nx build core` to build the library.

package/lib/auth/bypass/index.d.ts

@@ -0,0 +1,49 @@
+import { AbstractAuthenticationProvider } from '@streamlayer/sdk-web-interfaces';
+import { Transport } from '@streamlayer/sdk-web-api';
+import { CoreStore } from '../../store/store';
+/**
+ * An authorization service manages user access by providing login, logout,
+ * authentication checks, and the ability to revoke access.
+ * Subscribed to $userStore and automatically updates the auth header for the Transport.
+ */
+export declare class BypassAuth extends AbstractAuthenticationProvider {
+    private readonly $coreStore;
+    private readonly transport;
+    private readonly bypassLogin;
+    constructor(store: CoreStore, transport: Transport);
+    me: () => Promise<import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined>;
+    /**
+     * Login user by token and schema.
+     * On success, save the user and update the token to the Transport, UserStore and cache.
+     * @param schema - schema created by the host app and provided to the StreamLayer SDK.
+     * @param userKey - user token received from the host app.
+     */
+    login: (schema: string, userKey: string) => Promise<string>;
+    isAuthenticated: () => Promise<import("@streamlayer/sl-eslib/users/users_common_pb").User | undefined>;
+    /**
+     * Logout user. Clears the all user data from the store.
+     */
+    logout: () => void;
+    /**
+     * Soft logout, only clears the StreamLayer user data from the store.
+     * Does not clear the external token. And automatically tries to re-login by external token.
+     */
+    softLogout: () => void;
+    /**
+     * Try to re-login.
+     * - If the user has an token, then try to login by it, by calling the me() method.
+     * - If the user has an external token, then try to login by it, by calling the login() method. On failure, logout.
+     * -
+     * - If no one of the above is true, then logout.
+     */
+    reLogin: () => Promise<void> | undefined;
+    /**
+     * Write token to the Transport and UserStore
+     */
+    private saveUser;
+    /**
+     * Add interceptor to the Transport to handle 401 and 403 errors.
+     * If the user is logged in (auth header is set), then make a soft logout.
+     */
+    private connect;
+}

package/lib/auth/bypass/index.js

@@ -0,0 +1,132 @@
+import { AbstractAuthenticationProvider } from '@streamlayer/sdk-web-interfaces';
+import { queries } from '@streamlayer/sdk-web-api';
+import { UserStorage } from '../../storage';
+/**
+ * An authorization service manages user access by providing login, logout,
+ * authentication checks, and the ability to revoke access.
+ * Subscribed to $userStore and automatically updates the auth header for the Transport.
+ */
+export class BypassAuth extends AbstractAuthenticationProvider {
+    $coreStore;
+    transport;
+    bypassLogin;
+    constructor(store, transport) {
+        super();
+        this.$coreStore = store;
+        this.transport = transport;
+        this.bypassLogin = queries.bypassLogin(this.transport);
+        this.connect();
+    }
+    me = async () => {
+        this.$coreStore.getValues().user.invalidate();
+        const res = await this.$coreStore.getValues().user.getValue();
+        return res?.data;
+    };
+    /**
+     * Login user by token and schema.
+     * On success, save the user and update the token to the Transport, UserStore and cache.
+     * @param schema - schema created by the host app and provided to the StreamLayer SDK.
+     * @param userKey - user token received from the host app.
+     */
+    login = async (schema, userKey) => {
+        this.$coreStore.getValues().userKey.setValue(userKey);
+        const user = await this.bypassLogin({ schema, userKey, init: false });
+        const token = user.meta?.jwt;
+        const userId = user.data?.id;
+        if (!token || !userId) {
+            throw new Error('internal: token missing');
+        }
+        this.$coreStore.getValues().user.getStore().mutate(user);
+        this.saveUser(token, userId);
+        return token;
+    };
+    isAuthenticated = () => {
+        return this.me();
+    };
+    /**
+     * Logout user. Clears the all user data from the store.
+     */
+    logout = () => {
+        this.$coreStore.getValues().user.setValue();
+        this.$coreStore.getValues().userKey.setValue();
+        this.$coreStore.getValues().userToken.setValue();
+        this.transport.setAuth('', '');
+        const storage = new UserStorage();
+        storage.clear();
+    };
+    /**
+     * Soft logout, only clears the StreamLayer user data from the store.
+     * Does not clear the external token. And automatically tries to re-login by external token.
+     */
+    softLogout = () => {
+        const storage = new UserStorage();
+        this.$coreStore.getValues().user.setValue();
+        this.$coreStore.getValues().userToken.setValue();
+        this.transport.setAuth('', '');
+        storage.setToken('');
+        void this.reLogin();
+    };
+    /**
+     * Try to re-login.
+     * - If the user has an token, then try to login by it, by calling the me() method.
+     * - If the user has an external token, then try to login by it, by calling the login() method. On failure, logout.
+     * -
+     * - If no one of the above is true, then logout.
+     */
+    reLogin = () => {
+        const storage = new UserStorage();
+        const prevUserToken = storage.getToken();
+        const prevUserExternalToken = storage.getExternalToken();
+        this.$coreStore.getValues().userKey.setValue(prevUserExternalToken);
+        this.$coreStore.getValues().userToken.setValue(prevUserToken);
+        if (prevUserToken) {
+            this.saveUser(prevUserToken, '');
+            return this.me().then((user) => {
+                console.log('user', user);
+                if (user?.id) {
+                    const userId = user.id;
+                    this.saveUser(prevUserToken, userId);
+                }
+            });
+        }
+        if (prevUserExternalToken && !prevUserToken) {
+            const prevUserSchema = storage.getSchema();
+            if (prevUserSchema && prevUserExternalToken) {
+                this.login(prevUserSchema, prevUserExternalToken).catch(() => {
+                    this.logout();
+                });
+            }
+        }
+        return undefined;
+    };
+    /**
+     * Write token to the Transport and UserStore
+     */
+    saveUser = (token, userId) => {
+        this.transport.setAuth(token, userId);
+        this.$coreStore.getValues().userToken.setValue(token);
+        const storage = new UserStorage();
+        storage.setToken(token);
+    };
+    /**
+     * Add interceptor to the Transport to handle 401 and 403 errors.
+     * If the user is logged in (auth header is set), then make a soft logout.
+     */
+    connect = () => {
+        this.transport.registerInterceptor((next) => async (req) => {
+            try {
+                return await next(req);
+            }
+            catch (err) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                if (err.code && (err.code === 7 || err.code === 16)) {
+                    if (this.transport.getHeader('authorization')) {
+                        this.softLogout();
+                    }
+                }
+                throw err;
+            }
+        });
+    };
+}

package/lib/auth/index.d.ts

@@ -0,0 +1,22 @@
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+import { CoreStores, StoreObj } from '../store/store';
+import { UserStorage } from '../storage';
+import { BypassAuth } from './bypass';
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerSDK {
+        authorizationBypass: (schema: string, userKey: string) => Promise<void>;
+        logout: () => void;
+        getUserStore: () => CoreStores['user'];
+        userId: StoreObj['user']['getAtomStore'];
+        isUserAuthorized: BypassAuth['isAuthenticated'];
+    }
+    interface StreamLayerContext {
+        auth: BypassAuth;
+    }
+}
+export declare const storage: UserStorage;
+/**
+ * Bypass authorization, used for login with external token.
+ * Automatically login user if SDK initialized and READY.
+ */
+export declare const bypass: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;

package/lib/auth/index.js

@@ -0,0 +1,43 @@
+import { CoreStatus } from '../store/store';
+import { UserStorage } from '../storage';
+import { BypassAuth } from './bypass';
+export const storage = new UserStorage();
+/**
+ * Bypass authorization, used for login with external token.
+ * Automatically login user if SDK initialized and READY.
+ */
+export const bypass = (instance, opts, done) => {
+    instance.auth = new BypassAuth(instance.store, instance.transport);
+    instance.stores.status.listen((status) => {
+        if (status === CoreStatus.READY) {
+            void instance.auth.reLogin();
+        }
+    });
+    instance.sdk.userId = instance.stores.user.getAtomStore;
+    instance.sdk.authorizationBypass = async (schema, userKey) => {
+        if (storage.getSchema() === schema &&
+            storage.getExternalToken() === userKey &&
+            instance.transport.getHeader('authorization')) {
+            return;
+        }
+        try {
+            await instance.auth.login(schema, userKey);
+            storage.setSchema(schema);
+            storage.setExternalToken(userKey);
+        }
+        catch (err) {
+            instance.sdk.logout();
+        }
+    };
+    instance.sdk.logout = () => {
+        instance.auth.logout();
+        storage.clear();
+    };
+    instance.sdk.getUserStore = () => {
+        return instance.stores.user.getStore();
+    };
+    instance.sdk.isUserAuthorized = () => {
+        return instance.auth.isAuthenticated();
+    };
+    done();
+};

package/lib/environments/environment.d.ts

@@ -0,0 +1,3 @@
+export declare const environment: {
+    production: boolean;
+};

package/lib/environments/environment.js

@@ -0,0 +1,5 @@
+// This file can be replaced during build by using the `fileReplacements` array.
+// When building for production, this file is replaced with `environment.prod.ts`.
+export const environment = {
+    production: false,
+};

package/lib/environments/environment.prod.d.ts

@@ -0,0 +1,3 @@
+export declare const environment: {
+    production: boolean;
+};

package/lib/environments/environment.prod.js

@@ -0,0 +1,3 @@
+export const environment = {
+    production: true,
+};

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+export { bypass, storage } from './auth';
+export { store } from './store';
+import './store';
+import './auth';
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerSDK {
+        initializeApp: () => Promise<{
+            enabled?: boolean;
+            err?: string;
+        }>;
+        disableApp: () => void;
+        createEventSession: (providerStreamId: string) => void;
+    }
+}
+/**
+ * The main application instance is the core of a application. It includes:
+ * Store: Manages data storage.
+ * Public Methods: Provides a way to interact with the application.
+ * Connect Features: Handles communication between components through store.
+ * Connect Transport: Handles communication with api.
+ * Dependency Injection: Incorporates other necessary instances.
+ * Error Handling: Manages errors and logs them.
+ * Security: Implements authentication and authorization.
+ */
+export declare const core: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;

package/lib/index.js

@@ -0,0 +1,61 @@
+import { CoreStatus } from './store/store';
+export { bypass, storage } from './auth';
+export { store } from './store';
+import './store';
+import './auth';
+/**
+ * The main application instance is the core of a application. It includes:
+ * Store: Manages data storage.
+ * Public Methods: Provides a way to interact with the application.
+ * Connect Features: Handles communication between components through store.
+ * Connect Transport: Handles communication with api.
+ * Dependency Injection: Incorporates other necessary instances.
+ * Error Handling: Manages errors and logs them.
+ * Security: Implements authentication and authorization.
+ */
+export const core = (instance, opts, done) => {
+    instance.sdk = Object.create(null);
+    /**
+     * On initialize we subscribe to store and launch listeners
+     * that activate data downloading over the network
+     */
+    instance.sdk.initializeApp = async () => {
+        if (instance.stores.enabled.get() === 'on') {
+            return { enabled: true };
+        }
+        instance.storeSubscribe();
+        instance.stores.enabled.setValue('on');
+        instance.stores.status.setValue(CoreStatus.INITIALIZATION);
+        try {
+            const organizationSettings = await instance.stores.organizationSettings.getValue();
+            if (organizationSettings) {
+                instance.stores.status.setValue(CoreStatus.READY);
+                return { enabled: !!organizationSettings };
+            }
+            instance.stores.status.setValue(CoreStatus.FAILED);
+            return { err: 'failed' };
+        }
+        catch (err) {
+            instance.stores.enabled.setValue();
+            instance.stores.status.setValue(CoreStatus.FAILED);
+            return { err: `${err}` };
+        }
+    };
+    instance.sdk.disableApp = () => {
+        if (instance.stores.enabled.get() !== 'on') {
+            return;
+        }
+        instance.stores.enabled.setValue();
+        instance.stores.status.setValue(CoreStatus.DISABLED);
+        instance.sdk.closeFeature();
+        instance.storeUnsubscribe();
+    };
+    /**
+     * Configure the "event id" using the "provider," enabling subscribed stores to
+     * trigger their logic in response to a new event.
+     */
+    instance.sdk.createEventSession = (providerStreamId) => {
+        instance.stores.providerStreamId.setValue(providerStreamId);
+    };
+    done();
+};

package/lib/storage.d.ts

@@ -0,0 +1,11 @@
+import { Storage } from '@streamlayer/sdk-web-storage';
+export declare class UserStorage extends Storage {
+    constructor();
+    setSchema: (value: string) => void;
+    getSchema: () => string | undefined;
+    setToken: (value: string) => void;
+    getToken: () => string | undefined;
+    setExternalToken: (value: string) => void;
+    getExternalToken: () => string | undefined;
+    removeToken: () => void;
+}

package/lib/storage.js

@@ -0,0 +1,36 @@
+import { Storage } from '@streamlayer/sdk-web-storage';
+var KEY_PREFIX;
+(function (KEY_PREFIX) {
+    KEY_PREFIX["SCHEMA"] = "schema";
+    KEY_PREFIX["EXTERNAL_TOKEN"] = "eToken";
+    KEY_PREFIX["TOKEN"] = "token";
+})(KEY_PREFIX || (KEY_PREFIX = {}));
+export class UserStorage extends Storage {
+    constructor() {
+        super('user');
+    }
+    // Schema
+    setSchema = (value) => {
+        this.write(KEY_PREFIX.SCHEMA, value);
+    };
+    getSchema = () => {
+        return this.read(KEY_PREFIX.SCHEMA);
+    };
+    // Token
+    setToken = (value) => {
+        this.write(KEY_PREFIX.TOKEN, value);
+    };
+    getToken = () => {
+        return this.read(KEY_PREFIX.TOKEN);
+    };
+    // External Token
+    setExternalToken = (value) => {
+        this.write(KEY_PREFIX.EXTERNAL_TOKEN, value);
+    };
+    getExternalToken = () => {
+        return this.read(KEY_PREFIX.EXTERNAL_TOKEN);
+    };
+    removeToken = () => {
+        this.remove(KEY_PREFIX.TOKEN);
+    };
+}

package/lib/store/index.d.ts

@@ -0,0 +1,21 @@
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+import { CoreStore, CoreStores, StoreObj } from './store';
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerSDK {
+        sdkStore: CoreStores;
+        enabled: CoreStores['enabled'];
+        status: CoreStores['status'];
+        organizationStore: () => CoreStores['organizationSettings'];
+        streamStore: () => CoreStores['streamSettings'];
+    }
+    interface StreamLayerContext {
+        store: CoreStore;
+        stores: StoreObj;
+        storeSubscribe: () => void;
+        storeUnsubscribe: () => void;
+    }
+}
+/**
+ * store plugin, connect store to sdk
+ */
+export declare const store: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;

package/lib/store/index.js

@@ -0,0 +1,17 @@
+import { CoreStore } from './store';
+/**
+ * store plugin, connect store to sdk
+ */
+export const store = (instance, opts, done) => {
+    instance.store = new CoreStore(instance.transport);
+    instance.stores = instance.store.getValues();
+    instance.sdk.enabled = instance.stores.enabled.getStore();
+    instance.sdk.status = instance.stores.status.getStore();
+    instance.sdk.sdkStore = Object.fromEntries(Object.entries(instance.stores).map(([key, store]) => [key, store.getStore()]));
+    instance.sdk.organizationStore = () => instance.stores.organizationSettings.getStore();
+    instance.sdk.streamStore = () => instance.stores.streamSettings.getStore();
+    instance.storeUnsubscribe = () => {
+        instance.store.unsubscribe();
+    };
+    done();
+};

package/lib/store/init.d.ts

@@ -0,0 +1,54 @@
+import { SingleStore, ApiStore } from '@streamlayer/sdk-web-interfaces';
+import { Transport } from '@streamlayer/sdk-web-api';
+export declare enum CoreStatus {
+    DISABLED = "disabled",
+    INITIALIZATION = "initialization",
+    READY = "ready",
+    FAILED = "failed",
+    SUSPENDED = "suspended"
+}
+export declare const initializeStore: (transport: Transport) => {
+    readonly enabled: SingleStore<unknown, import("nanostores").WritableAtom<"on" | undefined>>;
+    readonly status: SingleStore<unknown, import("nanostores").WritableAtom<CoreStatus>>;
+    readonly providerStreamId: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+    readonly slStreamId: ApiStore<string | undefined, import("@nanostores/query").FetcherStore<string | undefined, any>>;
+    readonly streamSettings: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, any>>;
+    readonly user: ApiStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, any>>;
+    readonly userKey: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+    readonly userToken: SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+    readonly userSettings: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>>;
+    readonly organizationSettings: ApiStore<{
+        id: string;
+        overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
+        buttonIcon?: string | undefined;
+        tinodeHost?: string | undefined;
+        audience?: string | undefined;
+        name?: string | undefined;
+        provider?: string | undefined;
+        primaryColor?: string | undefined;
+        secondaryColor?: string | undefined;
+        moderationPrimaryColor?: string | undefined;
+        linkShareIcon?: string | undefined;
+        linkShareText?: string | undefined;
+        brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults | undefined;
+        pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+        getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+    } | undefined, import("@nanostores/query").FetcherStore<{
+        id: string;
+        overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
+        buttonIcon?: string | undefined;
+        tinodeHost?: string | undefined;
+        audience?: string | undefined;
+        name?: string | undefined;
+        provider?: string | undefined;
+        primaryColor?: string | undefined;
+        secondaryColor?: string | undefined;
+        moderationPrimaryColor?: string | undefined;
+        linkShareIcon?: string | undefined;
+        linkShareText?: string | undefined;
+        brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults | undefined;
+        pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+        getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+    } | undefined, any>>;
+    readonly organizationAdvertising: ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>>;
+};

package/lib/store/init.js

@@ -0,0 +1,71 @@
+import { createSingleStore, SingleStore, ApiStore } from '@streamlayer/sdk-web-interfaces';
+import { queries } from '@streamlayer/sdk-web-api';
+import { UserStorage } from '../storage';
+export var CoreStatus;
+(function (CoreStatus) {
+    CoreStatus["DISABLED"] = "disabled";
+    CoreStatus["INITIALIZATION"] = "initialization";
+    CoreStatus["READY"] = "ready";
+    CoreStatus["FAILED"] = "failed";
+    CoreStatus["SUSPENDED"] = "suspended";
+})(CoreStatus || (CoreStatus = {}));
+const initializeUserStores = (transport) => {
+    const storage = new UserStorage();
+    // host user key
+    const userKey = new SingleStore(createSingleStore(storage.getExternalToken()), 'userKey');
+    // sl user key
+    const userToken = new SingleStore(createSingleStore(storage.getToken()), 'userToken');
+    // sl user data
+    const user = new ApiStore(queries.$user(userToken.getStore(), transport), 'user', (data) => data?.data?.data?.id);
+    // sl user settings
+    const userSettings = new ApiStore(queries.$userSettings(userToken.getStore(), transport), 'userSettings');
+    return {
+        userKey,
+        userToken,
+        user,
+        userSettings,
+    };
+};
+const initializeStreamStores = (transport) => {
+    // host event id
+    const providerStreamId = new SingleStore(createSingleStore(undefined), 'providerStreamId');
+    // sl event id
+    const slStreamId = new ApiStore(queries.$retrieveEventId(providerStreamId.getStore(), transport), 'slStreamId', (data) => data?.data);
+    // sl stream settings
+    const streamSettings = new ApiStore(queries.$streamSettings(slStreamId.getAtomStore(), transport), 'streamSettings');
+    slStreamId.getAtomStore().listen((eventId) => {
+        if (eventId === '' || eventId === undefined) {
+            streamSettings.getStore().mutate(undefined);
+        }
+    });
+    return {
+        providerStreamId,
+        slStreamId,
+        streamSettings,
+    };
+};
+export const initializeStore = (transport) => {
+    // sdk toggle
+    const enabled = new SingleStore(createSingleStore(undefined), 'enabled');
+    // sdk status
+    const status = new SingleStore(createSingleStore(CoreStatus.DISABLED), 'status');
+    // sl organization settings
+    const organizationSettings = new ApiStore(queries.$organizationSettings(enabled.getStore(), transport), 'organizationSettings', (data) => data?.data?.id);
+    // sl organization advertising
+    const organizationAdvertising = new ApiStore(queries.$organizationAdvertising(organizationSettings.getAtomStore(), transport), 'organizationAdvertising');
+    const userStores = initializeUserStores(transport);
+    const streamStores = initializeStreamStores(transport);
+    return {
+        enabled,
+        status,
+        providerStreamId: streamStores.providerStreamId,
+        slStreamId: streamStores.slStreamId,
+        streamSettings: streamStores.streamSettings,
+        user: userStores.user,
+        userKey: userStores.userKey,
+        userToken: userStores.userToken,
+        userSettings: userStores.userSettings,
+        organizationSettings,
+        organizationAdvertising,
+    };
+};

package/lib/store/store.d.ts

@@ -0,0 +1,101 @@
+import type { OrganizationAdvertising, StreamSettings, OrganizationSettings, User, UserSettings } from '@streamlayer/sdk-web-types';
+import { AbstractStore } from '@streamlayer/sdk-web-interfaces';
+import { Transport } from '@streamlayer/sdk-web-api';
+import { ReadableAtom } from 'nanostores';
+import { FetcherValue } from '@nanostores/query';
+import { initializeStore, CoreStatus } from './init';
+export { CoreStatus };
+export interface CoreStoreInterface {
+    enabled?: 'on';
+    status: string;
+    userKey?: string;
+    userToken?: string;
+    organizationSettings?: OrganizationSettings & {
+        id: string;
+    };
+    organizationAdvertising?: OrganizationAdvertising;
+    streamSettings?: StreamSettings;
+    user?: User;
+    userSettings?: UserSettings;
+    providerStreamId?: string;
+    slStreamId?: string;
+}
+export type StoreObj = ReturnType<typeof initializeStore>;
+export type CoreStores = {
+    [Index in keyof StoreObj]: ReturnType<StoreObj[Index]['getStore']>;
+};
+export type CoreStoresValues = {
+    [Index in keyof StoreObj]: ReturnType<StoreObj[Index]['getStore']>['value'];
+};
+export type CoreStoreInstance = ReadableAtom<CoreStoresValues>;
+/**
+ * @description `CoreStore` is a store that contains all the necessary data for the SDK to work.
+ * `CoreStore` is a singleton and is created when the SDK is initialized. It includes the following stores:
+ * - `enabled` - the status of the SDK. The SDK is enabled when the `on` value is set.
+ * - `status` - the status of the SDK. Can be one of the following values: `disabled`, `initialization`, `ready`, `failed`, `suspended`.
+ * - `userKey` - the user key provided by the host.
+ * - `userToken` - the user token received from the StreamLayer after login.
+ * - `organizationSettings` - the organization settings.
+ * - `organizationAdvertising` - the organization advertising.
+ * - `streamSettings` - the stream settings.
+ * - `user` - the user data.
+ * - `userSettings` - the user settings.
+ * - `providerStreamId` - the event id provided by the host.
+ * - `slStreamId` - the event id received from the StreamLayer, resolved by the `providerStreamId`.
+ */
+export declare class CoreStore extends AbstractStore<CoreStoreInstance> {
+    private stores;
+    constructor(transport: Transport);
+    getValue(): unknown;
+    getValues(): {
+        readonly enabled: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").WritableAtom<"on" | undefined>>;
+        readonly status: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").WritableAtom<CoreStatus>>;
+        readonly providerStreamId: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        readonly slStreamId: import("@streamlayer/sdk-web-interfaces").ApiStore<string | undefined, import("@nanostores/query").FetcherStore<string | undefined, any>>;
+        readonly streamSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").StreamSettings | undefined, any>>;
+        readonly user: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/users/users_pb").MeResponse | undefined, any>>;
+        readonly userKey: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        readonly userToken: import("@streamlayer/sdk-web-interfaces").SingleStore<unknown, import("nanostores").WritableAtom<string | undefined>>;
+        readonly userSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/client/client_pb").ClientSettings | undefined, any>>;
+        readonly organizationSettings: import("@streamlayer/sdk-web-interfaces").ApiStore<{
+            id: string;
+            overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
+            buttonIcon?: string | undefined;
+            tinodeHost?: string | undefined;
+            audience?: string | undefined;
+            name?: string | undefined;
+            provider?: string | undefined;
+            primaryColor?: string | undefined;
+            secondaryColor?: string | undefined;
+            moderationPrimaryColor?: string | undefined;
+            linkShareIcon?: string | undefined;
+            linkShareText?: string | undefined;
+            brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults | undefined;
+            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+        } | undefined, import("@nanostores/query").FetcherStore<{
+            id: string;
+            overlays?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").SdkOverlay[] | undefined;
+            buttonIcon?: string | undefined;
+            tinodeHost?: string | undefined;
+            audience?: string | undefined;
+            name?: string | undefined;
+            provider?: string | undefined;
+            primaryColor?: string | undefined;
+            secondaryColor?: string | undefined;
+            moderationPrimaryColor?: string | undefined;
+            linkShareIcon?: string | undefined;
+            linkShareText?: string | undefined;
+            brandDefaults?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").BrandDefaults | undefined;
+            pub?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").JWK | undefined;
+            getstream?: import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").GetStreamSettingsClient | undefined;
+        } | undefined, any>>;
+        readonly organizationAdvertising: import("@streamlayer/sdk-web-interfaces").ApiStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, import("@nanostores/query").FetcherStore<import("@streamlayer/sl-eslib/sdkSettings/sdkSettings.common_pb").Advertising | undefined, any>>;
+    };
+    setValue(): void;
+    subscribe: (subscribes: Partial<StoreListeners>) => void;
+    unsubscribe: () => void;
+}
+export type StoreListeners = {
+    [Index in keyof StoreObj]: (params: FetcherValue<CoreStoreInterface[Index]>) => void;
+};

package/lib/store/store.js

@@ -0,0 +1,51 @@
+import { AbstractStore, mergeStores } from '@streamlayer/sdk-web-interfaces';
+import { initializeStore, CoreStatus } from './init';
+export { CoreStatus };
+/**
+ * @description `CoreStore` is a store that contains all the necessary data for the SDK to work.
+ * `CoreStore` is a singleton and is created when the SDK is initialized. It includes the following stores:
+ * - `enabled` - the status of the SDK. The SDK is enabled when the `on` value is set.
+ * - `status` - the status of the SDK. Can be one of the following values: `disabled`, `initialization`, `ready`, `failed`, `suspended`.
+ * - `userKey` - the user key provided by the host.
+ * - `userToken` - the user token received from the StreamLayer after login.
+ * - `organizationSettings` - the organization settings.
+ * - `organizationAdvertising` - the organization advertising.
+ * - `streamSettings` - the stream settings.
+ * - `user` - the user data.
+ * - `userSettings` - the user settings.
+ * - `providerStreamId` - the event id provided by the host.
+ * - `slStreamId` - the event id received from the StreamLayer, resolved by the `providerStreamId`.
+ */
+export class CoreStore extends AbstractStore {
+    stores;
+    constructor(transport) {
+        const storesObj = initializeStore(transport);
+        const store = mergeStores(storesObj);
+        super(store, 'core');
+        this.stores = storesObj;
+    }
+    getValue() {
+        throw new Error('Not implemented');
+    }
+    getValues() {
+        return this.stores;
+    }
+    setValue() {
+        throw new Error('Not implemented');
+    }
+    subscribe = (subscribes) => {
+        let storeKey;
+        for (storeKey in this.stores) {
+            const fn = subscribes[storeKey];
+            if (storeKey in subscribes && fn !== undefined) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                this.stores[storeKey].subscribe(subscribes[storeKey]);
+            }
+        }
+    };
+    unsubscribe = () => {
+        const store = this.getStore();
+        return store.off();
+    };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@streamlayer/sdk-web-core",
+  "devDependencies": {
+    "tslib": "^2.6.2"
+  },
+  "peerDependencies": {
+    "@nanostores/query": "^0.2.8",
+    "nanostores": "^0.9.5",
+    "@streamlayer/sl-eslib": "^5.53.6",
+    "@streamlayer/sdk-web-interfaces": "^0.18.15",
+    "@streamlayer/sdk-web-storage": "^0.0.4",
+    "@streamlayer/sdk-web-api": "^0.0.1",
+    "@streamlayer/sdk-web-types": "^0.0.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js",
+      "default": "./lib/index.js"
+    },
+    "./store": {
+      "types": "./lib/store/index.d.ts",
+      "import": "./lib/store/index.js",
+      "default": "./lib/store/index.js"
+    },
+    "./store/store": {
+      "types": "./lib/store/store.d.ts",
+      "import": "./lib/store/store.js",
+      "default": "./lib/store/store.js"
+    },
+    "./notifications": {
+      "types": "./lib/notifications/index.d.ts",
+      "import": "./lib/notifications/index.js",
+      "default": "./lib/notifications/index.js"
+    },
+    "./auth": {
+      "types": "./lib/auth/index.d.ts",
+      "import": "./lib/auth/index.js",
+      "default": "./lib/auth/index.js"
+    }
+  },
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "typings": "./lib/index.d.ts",
+  "files": [
+    "lib/",
+    "package.json"
+  ]
+}