@leanbase.com/js 0.1.2 → 0.2.0-alpha.0

package/dist/sessionid.d.ts

@@ -0,0 +1,50 @@
+import { SessionIdChangedCallback } from './types';
+import { Leanbase } from './leanbase';
+export declare const DEFAULT_SESSION_IDLE_TIMEOUT_SECONDS: number;
+export declare const MAX_SESSION_IDLE_TIMEOUT_SECONDS: number;
+export declare class SessionIdManager {
+    private readonly _sessionIdGenerator;
+    private readonly _windowIdGenerator;
+    private _config;
+    private _persistence;
+    private _windowId;
+    private _sessionId;
+    private readonly _window_id_storage_key;
+    private readonly _primary_window_exists_storage_key;
+    private _sessionStartTimestamp;
+    private _sessionActivityTimestamp;
+    private _sessionIdChangedHandlers;
+    private readonly _sessionTimeoutMs;
+    private _enforceIdleTimeout;
+    private _beforeUnloadListener;
+    private _eventEmitter;
+    on(event: 'forcedIdleReset', handler: () => void): () => void;
+    constructor(instance: Leanbase, sessionIdGenerator?: () => string, windowIdGenerator?: () => string);
+    get sessionTimeoutMs(): number;
+    onSessionId(callback: SessionIdChangedCallback): () => void;
+    private _canUseSessionStorage;
+    private _setWindowId;
+    private _getWindowId;
+    private _setSessionId;
+    private _getSessionId;
+    resetSessionId(): void;
+    /**
+     * Cleans up resources used by SessionIdManager.
+     * Should be called when the SessionIdManager is no longer needed to prevent memory leaks.
+     */
+    destroy(): void;
+    private _listenToReloadWindow;
+    private _sessionHasBeenIdleTooLong;
+    checkAndGetSessionAndWindowId(readOnly?: boolean, _timestamp?: number | null): {
+        sessionId: string;
+        windowId: string;
+        sessionStartTimestamp: number;
+        changeReason: {
+            noSessionId: boolean;
+            activityTimeout: boolean;
+            sessionPastMaximumLength: boolean;
+        } | undefined;
+        lastActivityTimestamp: number;
+    };
+    private _resetIdleTimer;
+}

package/dist/storage.d.ts

@@ -0,0 +1,24 @@
+import { PersistentStore } from './types';
+export declare const resetSubDomainCache: () => void;
+/**
+ * Browsers don't offer a way to check if something is a public suffix
+ * e.g. `.com.au`, `.io`, `.org.uk`
+ *
+ * But they do reject cookies set on public suffixes
+ * Setting a cookie on `.co.uk` would mean it was sent for every `.co.uk` site visited
+ *
+ * So, we can use this to check if a domain is a public suffix
+ * by trying to set a cookie on a subdomain of the provided hostname
+ * until the browser accepts it
+ *
+ * inspired by https://github.com/AngusFu/browser-root-domain
+ */
+export declare function seekFirstNonPublicSubDomain(hostname: string, cookieJar?: Document | undefined): string;
+export declare function chooseCookieDomain(hostname: string, cross_subdomain: boolean | undefined): string;
+export declare const cookieStore: PersistentStore;
+export declare const resetLocalStorageSupported: () => void;
+export declare const localStore: PersistentStore;
+export declare const localPlusCookieStore: PersistentStore;
+export declare const memoryStore: PersistentStore;
+export declare const resetSessionStorageSupported: () => void;
+export declare const sessionStore: PersistentStore;