@streamlayer/sdk-web-interfaces 0.0.1

package/README.md

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

package/lib/auth.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class AbstractAuthenticationProvider {
+    abstract login(...args: unknown[]): Promise<unknown>;
+    abstract logout(): void;
+    abstract me(): Promise<unknown>;
+    abstract isAuthenticated(): Promise<unknown>;
+}

package/lib/auth.js

@@ -0,0 +1,2 @@
+export class AbstractAuthenticationProvider {
+}

package/lib/feature.d.ts

@@ -0,0 +1,44 @@
+import { FeatureConfig as SdkOverlay, SdkOverlaySettings } from '@streamlayer/sdk-web-types';
+import { PlainMessage } from '@bufbuild/protobuf';
+import { WritableAtom } from 'nanostores';
+import { MapStore } from './store/map';
+type FeatureListener = {
+    name: string;
+    enabled: boolean;
+    onEvent: (...args: unknown[]) => void;
+};
+export type FeatureProps = PlainMessage<SdkOverlay>;
+export declare enum FeatureSource {
+    ORGANIZATION = "ORGANIZATION",
+    STREAM = "STREAM"
+}
+type FeatureConfig = Omit<FeatureProps, 'settings'>;
+type FeatureSettings = Exclude<PlainMessage<SdkOverlaySettings>['overlaySettings'], {
+    case: 'inplay';
+} | {
+    case: 'getstream';
+} | {
+    case: undefined;
+}>;
+export declare enum FeatureStatus {
+    Ready = "ready",
+    Suspended = "suspended"
+}
+export declare class AbstractFeature<K extends FeatureSettings['case'] | undefined, C extends FeatureSettings['value'] = FeatureSettings['value']> {
+    status: WritableAtom<FeatureStatus>;
+    source: FeatureSource;
+    protected config: MapStore<FeatureConfig>;
+    protected settings: MapStore<C>;
+    protected listeners: Set<FeatureListener>;
+    protected settingsKey: K;
+    constructor({ settings, ...config }: FeatureProps, source: FeatureSource);
+    get featureConfig(): import("nanostores").MapStore<FeatureConfig>;
+    get featureSettings(): import("nanostores").MapStore<C>;
+    registerEventListener(listener: FeatureListener): void;
+    enable: () => void;
+    disable: () => void;
+    setFeatureConfig: ({ settings, ...config }: FeatureProps) => void;
+    update: (config: FeatureProps, source: FeatureSource) => void;
+    protected fireEvent(event: unknown): void;
+}
+export {};

package/lib/feature.js

@@ -0,0 +1,91 @@
+import { FeatureType } from '@streamlayer/sdk-web-types';
+import { atom } from 'nanostores';
+import { createMapStore, MapStore } from './store/map';
+export var FeatureSource;
+(function (FeatureSource) {
+    FeatureSource["ORGANIZATION"] = "ORGANIZATION";
+    FeatureSource["STREAM"] = "STREAM";
+})(FeatureSource || (FeatureSource = {}));
+const FeatureTypes = {
+    [FeatureType.BETTING]: 'betting',
+    [FeatureType.GAMES]: 'games',
+    [FeatureType.PUBLIC_CHAT]: 'publicChat',
+    [FeatureType.TWITTER]: 'twitter',
+};
+export var FeatureStatus;
+(function (FeatureStatus) {
+    FeatureStatus["Ready"] = "ready";
+    FeatureStatus["Suspended"] = "suspended";
+})(FeatureStatus || (FeatureStatus = {}));
+export class AbstractFeature {
+    status;
+    source;
+    config;
+    settings;
+    listeners = new Set();
+    settingsKey;
+    constructor({ settings, ...config }, source) {
+        this.settingsKey = FeatureTypes[config.type];
+        this.status = atom(FeatureStatus.Suspended);
+        this.config = new MapStore(createMapStore(config), `feature:config:${this.settingsKey}`);
+        if (this.settingsKey !== undefined && settings?.overlaySettings.case === this.settingsKey) {
+            this.settings = new MapStore(createMapStore(settings.overlaySettings.value), `feature:settings:${this.settingsKey}`);
+        }
+        else {
+            this.settings = new MapStore(createMapStore({}), `feature:settings:${this.settingsKey}`);
+        }
+        this.source = source;
+    }
+    get featureConfig() {
+        return this.config.getStore();
+    }
+    get featureSettings() {
+        return this.settings.getStore();
+    }
+    registerEventListener(listener) {
+        this.listeners.add(listener);
+    }
+    enable = () => {
+        this.status.set(FeatureStatus.Ready);
+    };
+    disable = () => {
+        this.status.set(FeatureStatus.Suspended);
+    };
+    setFeatureConfig = ({ settings, ...config }) => {
+        let configKey;
+        for (configKey in config) {
+            this.config.setValue(configKey, config[configKey]);
+        }
+        if (settings?.overlaySettings?.case !== undefined && settings?.overlaySettings.case === this.settingsKey) {
+            const newSettings = settings.overlaySettings.value;
+            if (newSettings !== undefined) {
+                let key;
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                for (key in newSettings) {
+                    console.log(key, newSettings[key]);
+                    if (newSettings[key] !== 0 && newSettings[key] !== '') {
+                        this.settings.setValue(key, newSettings[key]);
+                    }
+                }
+            }
+        }
+    };
+    update = (config, source) => {
+        if (this.source === FeatureSource.STREAM && source === FeatureSource.ORGANIZATION) {
+            return;
+        }
+        this.setFeatureConfig(config);
+        this.source = source;
+    };
+    fireEvent(event) {
+        for (const listener of this.listeners.values()) {
+            try {
+                listener.onEvent(event);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+import { FeatureType } from '@streamlayer/sdk-web-types';
+export { AbstractAuthenticationProvider } from './auth';
+export { AbstractFeature, FeatureSource, type FeatureProps, FeatureStatus } from './feature';
+export { MapStore, createMapStore } from './store/map';
+export type { MapStoreListeners } from './store/map';
+export { SingleStore, createSingleStore, createComputedStore } from './store/single';
+export { AbstractStore, mergeStores } from './store/abstract';
+export { ApiStore } from './store/api';
+export interface StreamLayerSDK {
+    openFeature: (featureType: FeatureType) => void;
+    closeFeature: () => void;
+}
+export interface StreamLayerContext {
+    sdk: StreamLayerSDK;
+}
+type DoneFn = Function;
+export type StreamLayerPlugin = (instance: StreamLayerContext, opts: unknown, done: DoneFn) => void;

package/lib/index.js

@@ -0,0 +1,6 @@
+export { AbstractAuthenticationProvider } from './auth';
+export { AbstractFeature, FeatureSource, FeatureStatus } from './feature';
+export { MapStore, createMapStore } from './store/map';
+export { SingleStore, createSingleStore, createComputedStore } from './store/single';
+export { AbstractStore, mergeStores } from './store/abstract';
+export { ApiStore } from './store/api';

package/lib/store/abstract.d.ts

@@ -0,0 +1,45 @@
+import type { AnyStore } from 'nanostores';
+declare global {
+    interface Window {
+        slStore: any;
+    }
+}
+/**
+ * An abstract store is a wrapper for third-party stores,
+ * providing developers with a consistent interface inspired
+ * by the "nanostore" pattern. This simplifies
+ * interactions with different storage systems.
+ */
+export declare abstract class AbstractStore<T extends AnyStore> {
+    /**
+     * store instance (nanostores)
+     */
+    protected readonly store: T;
+    protected readonly name: string;
+    constructor(store: T, name: string);
+    /**
+     * return store instance
+     */
+    getStore(): T;
+    /**
+     * get all store values
+     */
+    abstract getValues(): unknown;
+    /**
+     * get store value by key
+     */
+    abstract getValue(...args: unknown[]): unknown;
+    /**
+     * subscribe directly to store changes
+     */
+    abstract subscribe(...args: unknown[]): void;
+    /**
+     * unsubscribe directly to store change
+     */
+    abstract unsubscribe(): void;
+}
+/**
+ * Merge multiple stores into a single instance using a single
+ * subscribe handler, leveraging the `useStore` method from `@nanostores/react` for React subscriptions.
+ */
+export declare const mergeStores: <T extends Record<string, AbstractStore<AnyStore>>, K = { [Index in keyof T]: ReturnType<T[Index]["getStore"]>["value"]; }>(stores: T) => import("nanostores").ReadableAtom<K>;

package/lib/store/abstract.js

@@ -0,0 +1,84 @@
+import { computed } from 'nanostores';
+import { buildLogger } from '@nanostores/logger';
+import diff from 'microdiff';
+window.slStore = Object.create(null);
+const slStoreLogger = (store, name) => buildLogger(store, name, {
+    mount: ({ storeName }) => {
+        if (!window.slStore[storeName]) {
+            window.slStore[storeName] = { mounted: true, history: [{ type: 'mount' }] };
+        }
+        window.slStore[storeName].store = store;
+    },
+    unmount: ({ storeName }) => {
+        window.slStore[storeName].mounted = false;
+        window.slStore[storeName]?.history.push({ type: 'unmount' });
+    },
+    change: ({ actionName, storeName, changed, newValue, oldValue, valueMessage }) => {
+        window.slStore[storeName]?.history.push({
+            type: 'change',
+            changed,
+            newValue,
+            oldValue,
+            diff: diff({ ...oldValue }, { ...newValue }, { cyclesFix: false }),
+            actionName,
+            valueMessage,
+        });
+    },
+    action: {
+        start: ({ actionName, args, storeName }) => {
+            window.slStore[storeName]?.history.push({
+                type: 'action:start',
+                actionName,
+                args,
+                storeName,
+            });
+        },
+        error: ({ actionName, error, storeName }) => {
+            window.slStore[storeName]?.history.push({
+                type: 'action:error',
+                actionName,
+                error,
+            });
+        },
+        end: ({ actionName, storeName }) => {
+            window.slStore[storeName]?.history.push({
+                type: 'action:end',
+                actionName,
+            });
+        },
+    },
+});
+/**
+ * An abstract store is a wrapper for third-party stores,
+ * providing developers with a consistent interface inspired
+ * by the "nanostore" pattern. This simplifies
+ * interactions with different storage systems.
+ */
+export class AbstractStore {
+    /**
+     * store instance (nanostores)
+     */
+    store;
+    name;
+    constructor(store, name) {
+        this.store = store;
+        this.name = name;
+        if (process.env.NODE_ENV !== 'production') {
+            slStoreLogger(this.store, this.name);
+        }
+    }
+    /**
+     * return store instance
+     */
+    getStore() {
+        return this.store;
+    }
+}
+/**
+ * Merge multiple stores into a single instance using a single
+ * subscribe handler, leveraging the `useStore` method from `@nanostores/react` for React subscriptions.
+ */
+export const mergeStores = (stores) => {
+    const storeKeys = Object.keys(stores);
+    return computed(storeKeys.map((key) => stores[key].getStore()), (...storeValues) => Object.fromEntries(storeKeys.map((key, i) => [key, storeValues[i]])));
+};

package/lib/store/api.d.ts

@@ -0,0 +1,21 @@
+import type { FetcherStore, FetcherValue } from '@nanostores/query';
+import { WritableAtom } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for @nanostores/query FetcherStore
+ */
+export declare class ApiStore<StoreValue, StoreInstance extends FetcherStore<StoreValue, any> = FetcherStore<StoreValue, any>> extends AbstractStore<StoreInstance> {
+    private readonly atomStore;
+    constructor(store: StoreInstance, name: string, atomPicker?: (val: FetcherValue<StoreValue, unknown>, prevVal?: string) => string | undefined);
+    getAtomStore: () => WritableAtom<string | undefined>;
+    getValue: () => Promise<StoreValue | undefined>;
+    getValues: () => never;
+    setValue: (value?: StoreInstance['value']) => void;
+    subscribe: StoreInstance['subscribe'];
+    unsubscribe: () => never;
+    invalidate: () => void;
+    listen: (cb: Parameters<StoreInstance['listen']>[0]) => () => void;
+    get(): void;
+    key: () => string | undefined;
+    off: () => void;
+}

package/lib/store/api.js

@@ -0,0 +1,62 @@
+import { atom } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for @nanostores/query FetcherStore
+ */
+export class ApiStore extends AbstractStore {
+    atomStore;
+    constructor(store, name, atomPicker) {
+        super(store, `api:${name}`);
+        this.atomStore = atom();
+        if (atomPicker) {
+            store.subscribe((data) => {
+                const prev = this.atomStore.get();
+                const newValue = atomPicker(data, prev);
+                if (prev !== newValue) {
+                    this.atomStore.set(newValue);
+                }
+            });
+        }
+    }
+    getAtomStore = () => this.atomStore;
+    getValue = async () => {
+        const store = this.getStore();
+        if (store.value === undefined) {
+            throw new Error('no store');
+        }
+        await store.value.promise;
+        return store.get().data;
+    };
+    getValues = () => {
+        throw new Error('not implemented');
+    };
+    setValue = (value) => {
+        const store = this.getStore();
+        return store.set({ loading: false, data: value?.data });
+    };
+    subscribe = (listener) => {
+        const store = this.getStore();
+        return store.subscribe(listener);
+    };
+    unsubscribe = () => {
+        throw new Error('not implemented');
+    };
+    invalidate = () => {
+        this.store.invalidate();
+    };
+    listen = (cb) => {
+        const store = this.getStore();
+        return store.listen(cb);
+    };
+    get() {
+        throw new Error('not implemented');
+    }
+    key = () => {
+        const store = this.getStore();
+        return store.key;
+    };
+    off = () => {
+        const store = this.getStore();
+        return store.off();
+    };
+}

package/lib/store/map.d.ts

@@ -0,0 +1,19 @@
+import type { MapStoreKeys, MapStore as NMapStore } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for nanostores MapStore
+ */
+export declare class MapStore<StoreInterface extends object, StoreInstance extends NMapStore<StoreInterface> = NMapStore<StoreInterface>> extends AbstractStore<StoreInstance> {
+    getValues: () => StoreInterface;
+    getValue: (key: MapStoreKeys<StoreInstance>) => StoreInterface[MapStoreKeys<StoreInstance>];
+    setValue: <Key extends MapStoreKeys<StoreInstance>>(path: Key, value: StoreInterface[Key]) => void;
+    subscribe: StoreInstance['subscribe'];
+    unsubscribe: () => void;
+}
+/**
+ * create map store from nanostores
+ */
+export declare const createMapStore: <Data extends object>(initialData: Data) => NMapStore<Data>;
+export type MapStoreListeners<StoreInstance extends NMapStore<StoreInterface>, StoreInterface extends object> = {
+    [T in MapStoreKeys<StoreInstance>]: (value: StoreInterface[T]) => void;
+};

package/lib/store/map.js

@@ -0,0 +1,36 @@
+import { map } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for nanostores MapStore
+ */
+export class MapStore extends AbstractStore {
+    getValues = () => {
+        const store = this.getStore();
+        return store.get();
+    };
+    getValue = (key) => {
+        const store = this.getStore();
+        return store.get()[key];
+    };
+    setValue = (path, value) => {
+        const store = this.getStore();
+        // wrong infer type
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        return store.setKey(path, value);
+    };
+    subscribe = (...args) => {
+        const store = this.getStore();
+        return store.subscribe(...args);
+    };
+    unsubscribe = () => {
+        const store = this.getStore();
+        return store.off();
+    };
+}
+/**
+ * create map store from nanostores
+ */
+export const createMapStore = (initialData) => {
+    return map(initialData);
+};

package/lib/store/single.d.ts

@@ -0,0 +1,19 @@
+import type { StoreValue, WritableAtom } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for nanostores WritableAtom
+ */
+export declare class SingleStore<StoreValue, StoreInstance extends WritableAtom<StoreValue | undefined> = WritableAtom<StoreValue | undefined>> extends AbstractStore<StoreInstance> {
+    getValue: () => StoreInstance['value'];
+    getValues(): unknown;
+    setValue: (value?: StoreValue) => void;
+    subscribe: (listener: Parameters<StoreInstance['subscribe']>[0]) => () => void;
+    unsubscribe: () => void;
+    listen(listener: Parameters<StoreInstance['subscribe']>[0]): () => void;
+    get(): StoreValue | undefined;
+}
+/**
+ * create atom store from nanostores
+ */
+export declare const createSingleStore: <T>(initialData: T) => WritableAtom<T>;
+export declare const createComputedStore: <Value, T extends WritableAtom<any> = WritableAtom<any>>(store: T, mutator: (value: StoreValue<T>) => Value) => import("nanostores").ReadableAtom<Value>;

package/lib/store/single.js

@@ -0,0 +1,39 @@
+import { atom, computed } from 'nanostores';
+import { AbstractStore } from './abstract';
+/**
+ * Wrapper for nanostores WritableAtom
+ */
+export class SingleStore extends AbstractStore {
+    getValue = () => {
+        const store = this.getStore();
+        return store.get();
+    };
+    getValues() {
+        throw new Error('not implemented');
+    }
+    setValue = (value) => {
+        const store = this.getStore();
+        return store.set(value);
+    };
+    subscribe = (listener) => {
+        const store = this.getStore();
+        return store.subscribe(listener);
+    };
+    unsubscribe = () => {
+        const store = this.getStore();
+        return store.off();
+    };
+    listen(listener) {
+        const store = this.getStore();
+        return store.listen(listener);
+    }
+    get() {
+        const store = this.getStore();
+        return store.get();
+    }
+}
+/**
+ * create atom store from nanostores
+ */
+export const createSingleStore = (initialData) => atom(initialData);
+export const createComputedStore = (store, mutator) => computed(store, mutator);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@streamlayer/sdk-web-interfaces",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "./lib/index.js",
+  "typings": "./lib/index.d.ts",
+  "files": [
+    "lib/",
+    "package.json"
+  ],
+  "exports": {
+    ".": {
+      "module": "./lib/index.js",
+      "require": "./lib/index.js",
+      "types": "./lib/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "@nanostores/logger": "^0.2.4",
+    "@nanostores/query": "^0.2.8",
+    "nanostores": "^0.9.5",
+    "@bufbuild/protobuf": "^1.4.2",
+    "microdiff": "^1.3.2",
+    "@streamlayer/sdk-web-types": "^0.0.1"
+  },
+  "devDependencies": {
+    "tslib": "^2.6.2"
+  }
+}