@streamlayer/sdk-web-core 0.20.0 → 0.21.0

package/lib/auth/bypass/index.js

@@ -1,7 +1,9 @@
 import { AbstractAuthenticationProvider } from '@streamlayer/sdk-web-interfaces';
 import { queries } from '@streamlayer/sdk-web-api';
+import { createLogger } from '@streamlayer/sdk-web-logger';
 import { DEEP_LINK_USER_ID } from '../../deepLink';
 import { UserStorage } from '../../storage';
+const logger = createLogger('bypass');
 /**
  * An authorization service manages user access by providing login, logout,
  * authentication checks, and the ability to revoke access.
@@ -33,8 +35,9 @@ export class BypassAuth extends AbstractAuthenticationProvider {
      */
     login = async (schema, userKey) => {
         this.$coreStore.getValues().userKey.setValue(userKey);
-        const inviterKey = this.deepLink.getDeepLinkData()?.[DEEP_LINK_USER_ID];
-        console.log('inviterKey', inviterKey);
+        const { used, data } = this.deepLink.getDeepLinkData();
+        const inviterKey = !used ? data?.[DEEP_LINK_USER_ID] : '';
+        logger.debug('inviterKey', inviterKey);
         const user = await this.bypassLogin({
             schema,
             userKey,
@@ -46,7 +49,7 @@ export class BypassAuth extends AbstractAuthenticationProvider {
         if (!token || !userId) {
             throw new Error('internal: token missing');
         }
-        console.log('user', user);
+        logger.debug('user', user);
         if (user.meta?.inviterKey) {
             this.deepLink.deepLinkUsed(user.meta.inviterKey);
         }

package/lib/deepLink/index.d.ts

@@ -1,16 +1,15 @@
 import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 import { MapStore } from '@streamlayer/sdk-web-interfaces';
 type DeepLinkContextData = {
-    processed: boolean;
-    hash?: string;
-    search?: string;
-    sessionId?: string;
+    handled?: boolean;
+    parsed?: boolean;
+    used?: boolean;
     data?: DeepLinkUrlParams;
 };
 export type DeepLinkCallback = (deepLinkData: DeepLinkContextData['data']) => void;
 export interface DeepLinkContext {
     $store: DeepLinkContextStore;
-    getDeepLinkData: () => DeepLinkContextData['data'];
+    getDeepLinkData: () => Pick<DeepLinkContextData, 'data' | 'used'>;
     deepLinkUsed: (inviterId: string) => void;
     onDeepLinkHandlers: Set<DeepLinkCallback>;
 }
@@ -20,9 +19,10 @@ declare module '@streamlayer/sdk-web-interfaces' {
         deepLink: DeepLinkContext;
     }
     interface StreamLayerSDK {
-        onDeepLinkHandled: (cb: DeepLinkCallback) => void;
-        deepLinkHandled: () => void;
-        getInviterId: () => string | undefined;
+        addDeepLinkHandler: (cb: DeepLinkCallback) => void;
+        removeDeepLinkHandler: (cb: DeepLinkCallback) => void;
+        getInviter: () => string | undefined;
+        inviteDisplayed: () => void;
     }
 }
 export declare const DEEP_LINK_PREFIX = "sldl";

package/lib/deepLink/index.js

@@ -1,5 +1,6 @@
 import { createMapStore, MapStore } from '@streamlayer/sdk-web-interfaces';
 import { Storage } from '@streamlayer/sdk-web-storage';
+import { createLogger } from '@streamlayer/sdk-web-logger';
 class DeepLinkContextStorage extends Storage {
     get = this.read;
     set = this.write;
@@ -15,35 +16,62 @@ export const DEEP_LINK_EXTERNAL_EVENT_ID = 'sldl_e_eid';
 const ALLOWED_PARAMS = new Set([DEEP_LINK_USER_ID, DEEP_LINK_EVENT_ID, DEEP_LINK_EXTERNAL_EVENT_ID]);
 const pickOnlyAllowedParams = (params) => {
     const result = {};
+    const remain = {};
     for (const [key, value] of params) {
         if (ALLOWED_PARAMS.has(key)) {
             result[key] = value;
         }
+        else {
+            remain[key] = value;
+        }
     }
-    return result;
+    return { result, remain };
 };
 const parseDeepLinkData = ({ hash, search }) => {
     if (hash && hash.includes(DEEP_LINK_PREFIX)) {
         const params = new URLSearchParams(hash.substr(1));
-        return pickOnlyAllowedParams(params);
+        return { hash: pickOnlyAllowedParams(params) };
     }
     if (search && search.includes(DEEP_LINK_PREFIX)) {
         const params = new URLSearchParams(search);
-        return pickOnlyAllowedParams(params);
+        return { search: pickOnlyAllowedParams(params) };
     }
     return null;
 };
-const pickDeepLinkData = ($deepLinkContext) => {
-    const { hash, search, processed } = $deepLinkContext.getValues();
-    console.log('get deep link data from', { hash, search, processed });
-    if (!processed) {
-        const result = parseDeepLinkData({ hash, search });
-        console.log('parse deep link result', result);
-        if (result) {
-            $deepLinkContext.setValue('data', result);
+const logger = createLogger('deep_link');
+const pickDeepLinkData = ($deepLinkContext, deepLinkHandled) => {
+    const { hash, search } = window.location;
+    logger.debug({ hash, search }, 'get deep link data from');
+    if (hash || search) {
+        const parsedData = parseDeepLinkData({ hash, search });
+        logger.debug(parsedData, 'parse deep link result');
+        if (parsedData) {
+            const { hash, search } = parsedData;
+            const { result, remain } = hash || search;
+            if (Object.keys(result).length !== 0) {
+                $deepLinkContext.setValue('data', result);
+                const remainExist = Object.keys(remain).length !== 0;
+                if (hash) {
+                    let updatedHash = '';
+                    if (remainExist) {
+                        updatedHash = `#${new URLSearchParams(remain).toString()}`;
+                        logger.debug({ updatedHash }, 'update hash');
+                    }
+                    window.history.replaceState(null, '', window.location.pathname + window.location.search + updatedHash);
+                }
+                if (search) {
+                    let updatedSearch = '';
+                    if (remainExist) {
+                        updatedSearch = `?${new URLSearchParams(remain).toString()}`;
+                        logger.debug({ updatedSearch }, 'update search');
+                    }
+                    window.history.replaceState(null, '', window.location.pathname + updatedSearch + window.location.hash);
+                }
+                deepLinkHandled(result);
+            }
         }
-        return;
     }
+    $deepLinkContext.setValue('parsed', true);
     return;
 };
 /**
@@ -53,43 +81,50 @@ const pickDeepLinkData = ($deepLinkContext) => {
 export const deepLink = (instance, opts, done) => {
     const storage = new DeepLinkContextStorage();
     const initStoreStr = storage.get('sl-deep-link-store');
-    let initStore = { processed: false };
+    let initStore = {};
     if (initStoreStr) {
         try {
             initStore = JSON.parse(initStoreStr);
         }
         catch (e) {
-            console.log(e);
+            logger.debug(e);
         }
     }
     instance.deepLink = {
         $store: new MapStore(createMapStore(initStore), 'deep-link-context'),
         getDeepLinkData: () => {
-            const { data, processed } = instance.deepLink.$store.getValues();
-            return !processed ? data : undefined;
+            const { data, used } = instance.deepLink.$store.getValues();
+            return { data, used };
         },
         // we are logged in with inviter id
         deepLinkUsed: (inviterId) => {
-            instance.deepLink.$store.setValue('processed', true);
-            storage.set('sl-inviter-id', inviterId);
-            storage.del('sl-location');
+            logger.debug(`logged in with inviterId: ${inviterId}`);
+            instance.deepLink.$store.setValue('used', true);
         },
         onDeepLinkHandlers: new Set(),
     };
-    instance.deepLink.$store.subscribe((value) => storage.set('sl-deep-link-store', JSON.stringify(value)));
-    instance.sdk.getInviterId = () => {
-        return storage.get('sl-inviter-id');
+    instance.sdk.getInviter = () => {
+        const { data, used } = instance.deepLink.getDeepLinkData();
+        return used ? data?.[DEEP_LINK_USER_ID] : undefined;
     };
-    instance.sdk.onDeepLinkHandled = (cb) => {
+    instance.sdk.inviteDisplayed = () => {
+        instance.deepLink.$store.getStore().set({});
+        instance.deepLink.$store.getStore().off();
+        storage.del('sl-deep-link-store');
+    };
+    instance.deepLink.$store.subscribe((value) => storage.set('sl-deep-link-store', JSON.stringify(value)));
+    instance.sdk.addDeepLinkHandler = (cb) => {
         instance.deepLink.onDeepLinkHandlers.add(cb);
     };
-    // sdk initialized after login by invite
-    instance.sdk.deepLinkHandled = () => {
-        storage.del('sl-inviter-id');
-        instance.deepLink.$store.setValue('processed', true);
-        const { data } = instance.deepLink.$store.getValues();
+    instance.sdk.removeDeepLinkHandler = (cb) => {
+        instance.deepLink.onDeepLinkHandlers.delete(cb);
+    };
+    // called after sdk parsed deep link data from location
+    const deepLinkHandled = (data) => {
+        instance.deepLink.$store.setValue('handled', true);
         for (const handler of instance.deepLink.onDeepLinkHandlers) {
             try {
+                logger.debug('called handler');
                 handler(data);
             }
             catch (err) {
@@ -97,21 +132,6 @@ export const deepLink = (instance, opts, done) => {
             }
         }
     };
-    let sessionId = storage.get('sl-session-id');
-    if (!sessionId) {
-        const { hash, search } = window.location;
-        sessionId = Date.now().toString();
-        storage.set('sl-session-id', sessionId);
-        storage.set('sl-location', JSON.stringify({ hash, search }));
-        instance.deepLink.$store.getStore().set({ sessionId, hash, search, processed: false });
-    }
-    else {
-        const initialLocation = storage.get('sl-location');
-        if (initialLocation) {
-            const parsed = JSON.parse(initialLocation);
-            instance.deepLink.$store.getStore().set({ sessionId, hash: parsed.hash, search: parsed.search, processed: false });
-        }
-    }
-    pickDeepLinkData(instance.deepLink.$store);
+    pickDeepLinkData(instance.deepLink.$store, deepLinkHandled);
     done();
 };

package/lib/index.d.ts

@@ -2,6 +2,7 @@ import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
 export { bypass, storage } from './auth';
 export { store } from './store';
 export { deepLink, type DeepLinkUrlParams, type DeepLinkCallback, DEEP_LINK_PREFIX, DEEP_LINK_USER_ID, DEEP_LINK_EVENT_ID, DEEP_LINK_EXTERNAL_EVENT_ID, } from './deepLink';
+export { videoPlayer, type VideoPlayerCallback } from './videoPlayer';
 import './store';
 import './auth';
 declare module '@streamlayer/sdk-web-interfaces' {

package/lib/index.js

@@ -2,6 +2,7 @@ import { CoreStatus } from './store/store';
 export { bypass, storage } from './auth';
 export { store } from './store';
 export { deepLink, DEEP_LINK_PREFIX, DEEP_LINK_USER_ID, DEEP_LINK_EVENT_ID, DEEP_LINK_EXTERNAL_EVENT_ID, } from './deepLink';
+export { videoPlayer } from './videoPlayer';
 import './store';
 import './auth';
 /**

package/lib/videoPlayer/index.d.ts

@@ -0,0 +1,19 @@
+import { StreamLayerContext } from '@streamlayer/sdk-web-interfaces';
+export type VideoPlayerData = {
+    muted: boolean;
+};
+export type VideoPlayerCallback = (videoPlayerData: VideoPlayerData) => void;
+export interface VideoPlayerContext {
+    controllers: Set<VideoPlayerCallback>;
+}
+declare module '@streamlayer/sdk-web-interfaces' {
+    interface StreamLayerContext {
+        videoPlayer: VideoPlayerContext;
+    }
+    interface StreamLayerSDK {
+        addVideoPlayerController: (cb: VideoPlayerCallback) => void;
+        removeVideoPlayerController: (cb: VideoPlayerCallback) => void;
+        controlVideoPlayer: VideoPlayerCallback;
+    }
+}
+export declare const videoPlayer: (instance: StreamLayerContext, opts: unknown, done: () => void) => void;

package/lib/videoPlayer/index.js

@@ -0,0 +1,22 @@
+export const videoPlayer = (instance, opts, done) => {
+    instance.videoPlayer = {
+        controllers: new Set(),
+    };
+    instance.sdk.addVideoPlayerController = (cb) => {
+        instance.videoPlayer.controllers.add(cb);
+    };
+    instance.sdk.removeVideoPlayerController = (cb) => {
+        instance.videoPlayer.controllers.delete(cb);
+    };
+    instance.sdk.controlVideoPlayer = (props) => {
+        for (const controller of instance.videoPlayer.controllers) {
+            try {
+                controller(props);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    };
+    done();
+};

package/package.json

@@ -7,10 +7,11 @@
     "@nanostores/query": "^0.2.8",
     "@streamlayer/sl-eslib": "^5.67.0",
     "nanostores": "^0.9.5",
-    "@streamlayer/sdk-web-api": "^0.21.1",
-    "@streamlayer/sdk-web-interfaces": "^0.20.3",
-    "@streamlayer/sdk-web-storage": "^0.4.1",
-    "@streamlayer/sdk-web-types": "^0.22.1"
+    "@streamlayer/sdk-web-api": "^0.22.0",
+    "@streamlayer/sdk-web-interfaces": "^0.20.5",
+    "@streamlayer/sdk-web-storage": "^0.4.3",
+    "@streamlayer/sdk-web-logger": "^0.5.16",
+    "@streamlayer/sdk-web-types": "^0.22.3"
   },
   "exports": {
     ".": {
@@ -39,7 +40,7 @@
       "default": "./lib/auth/index.js"
     }
   },
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "main": "./lib/index.js",
   "module": "./lib/index.js",