posthog-js-lite 2.0.0-alpha4 → 2.0.0

package/lib/posthog-core/src/index.d.ts

@@ -5,9 +5,10 @@ import { LZString } from './lz-string';
 import { SimpleEventEmitter } from './eventemitter';
 export declare abstract class PostHogCore {
     private apiKey;
-    private host;
+    host: string;
     private flushAt;
     private flushInterval;
+    private requestTimeout;
     private captureMode;
     private sendFeatureFlagEvent;
     private flagCallReported;
@@ -15,8 +16,6 @@ export declare abstract class PostHogCore {
     protected _events: SimpleEventEmitter;
     protected _flushTimer?: any;
     protected _decideResponsePromise?: Promise<PostHogDecideResponse>;
-    protected _decideTimer?: any;
-    protected _decidePollInterval: number;
     protected _retryOptions: RetriableOptions;
     protected _sessionExpirationTimeSeconds: number;
     abstract fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
@@ -28,18 +27,21 @@ export declare abstract class PostHogCore {
     private _optoutOverride;
     constructor(apiKey: string, options?: PosthogCoreOptions);
     protected getCommonEventProperties(): any;
+    protected setupBootstrap(options?: Partial<PosthogCoreOptions>): void;
     private get props();
     private set props(value);
+    private clearProps;
     private _props;
     get optedOut(): boolean;
     optIn(): void;
     optOut(): void;
     on(event: string, cb: (...args: any[]) => void): () => void;
-    reset(): void;
+    reset(propertiesToKeep?: PostHogPersistedProperty[]): void;
     debug(enabled?: boolean): void;
     private buildPayload;
     getSessionId(): string | undefined;
     resetSessionId(): void;
+    getAnonymousId(): string;
     getDistinctId(): string;
     register(properties: {
         [key: string]: any;
@@ -51,7 +53,7 @@ export declare abstract class PostHogCore {
     identify(distinctId?: string, properties?: PostHogEventProperties): this;
     capture(event: string, properties?: {
         [key: string]: any;
-    }): this;
+    }, forceSendFeatureFlags?: boolean): this;
     alias(alias: string): this;
     autocapture(eventType: string, elements: PostHogAutocaptureElement[], properties?: PostHogEventProperties): this;
     /***
@@ -62,17 +64,31 @@ export declare abstract class PostHogCore {
     }): this;
     group(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
     groupIdentify(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties): this;
+    /***
+     * PROPERTIES
+     ***/
+    personProperties(properties: {
+        [type: string]: string;
+    }): this;
+    groupProperties(properties: {
+        [type: string]: Record<string, string>;
+    }): this;
     /***
      *** FEATURE FLAGS
      ***/
     private decideAsync;
     private _decideAsync;
-    getFeatureFlag(key: string, defaultResult?: string | boolean): boolean | string | undefined;
+    private setKnownFeatureFlags;
+    getFeatureFlag(key: string): boolean | string | undefined;
     getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
-    isFeatureEnabled(key: string, defaultResult?: boolean): boolean;
-    reloadFeatureFlagsAsync(): Promise<PostHogDecideResponse['featureFlags']>;
+    isFeatureEnabled(key: string): boolean | undefined;
+    reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags']>;
     onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
+    onFeatureFlag(key: string, cb: (value: string | boolean) => void): () => void;
     overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): void;
+    _sendFeatureFlags(event: string, properties?: {
+        [key: string]: any;
+    }): void;
     /***
      *** QUEUEING AND FLUSHING
      ***/

package/lib/posthog-core/src/types.d.ts

@@ -5,13 +5,19 @@ export declare type PosthogCoreOptions = {
     enable?: boolean;
     sendFeatureFlagEvent?: boolean;
     preloadFeatureFlags?: boolean;
-    decidePollInterval?: number;
+    bootstrap?: {
+        distinctId?: string;
+        isIdentifiedId?: boolean;
+        featureFlags?: Record<string, boolean | string>;
+    };
     fetchRetryCount?: number;
     fetchRetryDelay?: number;
+    requestTimeout?: number;
     sessionExpirationTimeSeconds?: number;
     captureMode?: 'json' | 'form';
 };
 export declare enum PostHogPersistedProperty {
+    AnonymousId = "anonymous_id",
     DistinctId = "distinct_id",
     Props = "props",
     FeatureFlags = "feature_flags",
@@ -19,7 +25,9 @@ export declare enum PostHogPersistedProperty {
     Queue = "queue",
     OptedOut = "opted_out",
     SessionId = "session_id",
-    SessionLastTimestamp = "session_timestamp"
+    SessionLastTimestamp = "session_timestamp",
+    PersonProperties = "person_properties",
+    GroupProperties = "group_properties"
 }
 export declare type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -28,11 +36,13 @@ export declare type PostHogFetchOptions = {
     headers: {
         [key: string]: string;
     };
-    body: string;
+    body?: string;
+    signal?: AbortSignal;
 };
 export declare type PostHogFetchResponse = {
     status: number;
     text: () => Promise<string>;
+    json: () => Promise<any>;
 };
 export declare type PostHogQueueItem = {
     message: any;

package/lib/posthog-core/src/utils.d.ts

@@ -9,5 +9,4 @@ export declare function retriable<T>(fn: () => Promise<T>, props?: RetriableOpti
 export declare function generateUUID(globalThis?: any): string;
 export declare function currentTimestamp(): number;
 export declare function currentISOTime(): string;
-export declare function isUndefined(obj: any): boolean;
 export declare function safeSetTimeout(fn: () => void, timeout: number): any;

package/lib/posthog-web/src/posthog-web.d.ts

@@ -1,8 +1,5 @@
-import { PostHogCore, PosthogCoreOptions, PostHogFetchOptions, PostHogFetchResponse, PostHogPersistedProperty } from '../../posthog-core/src';
-export interface PostHogOptions extends PosthogCoreOptions {
-    autocapture?: boolean;
-    persistence_name?: string;
-}
+import { PostHogCore, PostHogFetchOptions, PostHogFetchResponse, PostHogPersistedProperty } from '../../posthog-core/src';
+import { PostHogOptions } from './types';
 export declare class PostHog extends PostHogCore {
     private _storage;
     private _storageCache;

package/lib/posthog-web/src/storage.d.ts

@@ -1,3 +1,4 @@
+import { PostHogOptions } from './types';
 export declare type PostHogStorage = {
     getItem: (key: string) => string | null | undefined;
     setItem: (key: string, value: string) => void;
@@ -6,7 +7,4 @@ export declare type PostHogStorage = {
     getAllKeys: () => readonly string[];
 };
 export declare const cookieStore: PostHogStorage;
-export declare const _localStore: PostHogStorage;
-export declare const _sessionStore: PostHogStorage;
-export declare const localStore: PostHogStorage | undefined;
-export declare const sessionStorage: PostHogStorage | undefined;
+export declare const getStorage: (type: PostHogOptions['persistence'], window: Window | undefined) => PostHogStorage;

package/lib/posthog-web/src/types.d.ts

@@ -0,0 +1,6 @@
+import { PosthogCoreOptions } from '../../posthog-core/src';
+export declare type PostHogOptions = {
+    autocapture?: boolean;
+    persistence?: 'localStorage' | 'sessionStorage' | 'cookie' | 'memory';
+    persistence_name?: string;
+} & PosthogCoreOptions;

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "posthog-js-lite",
-  "version": "2.0.0-alpha4",
+  "version": "2.0.0",
   "main": "lib/index.cjs.js",
   "module": "lib/index.esm.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "test": "jest -c jest.config.js",
-    "prepublish": "cd .. && yarn build"
+    "prepublishOnly": "cd .. && yarn build"
   }
 }

package/src/posthog-web.ts

@@ -1,21 +1,16 @@
 import {
   PostHogCore,
-  PosthogCoreOptions,
   PostHogFetchOptions,
   PostHogFetchResponse,
   PostHogPersistedProperty,
 } from '../../posthog-core/src'
 import { getContext } from './context'
-import { localStore, cookieStore, sessionStorage } from './storage'
+import { PostHogStorage, getStorage } from './storage'
 import { version } from '../package.json'
-
-export interface PostHogOptions extends PosthogCoreOptions {
-  autocapture?: boolean
-  persistence_name?: string
-}
+import { PostHogOptions } from './types'
 
 export class PostHog extends PostHogCore {
-  private _storage = localStore || sessionStorage || cookieStore
+  private _storage: PostHogStorage
   private _storageCache: any
   private _storageKey: string
 
@@ -24,6 +19,8 @@ export class PostHog extends PostHogCore {
 
     // posthog-js stores options in one object on
     this._storageKey = options?.persistence_name ? `ph_${options.persistence_name}` : `ph_${apiKey}_posthog`
+    this._storage = getStorage(options?.persistence || 'localStorage', window)
+    this.setupBootstrap(options)
   }
 
   getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined {
@@ -51,12 +48,15 @@ export class PostHog extends PostHogCore {
   fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
     return window.fetch(url, options)
   }
+
   getLibraryId(): string {
     return 'posthog-js-lite'
   }
+
   getLibraryVersion(): string {
     return version
   }
+
   getCustomUserAgent(): void {
     return
   }

package/src/storage.ts

@@ -1,3 +1,5 @@
+import { PostHogOptions } from './types'
+
 export type PostHogStorage = {
   getItem: (key: string) => string | null | undefined
   setItem: (key: string, value: string) => void
@@ -90,9 +92,6 @@ const createStorageLike = (store: any): PostHogStorage => {
   }
 }
 
-export const _localStore = createStorageLike(window.localStorage)
-export const _sessionStore = createStorageLike(window.sessionStorage)
-
 const checkStoreIsSupported = (storage: PostHogStorage, key = '__mplssupport__'): boolean => {
   if (!window) {
     return false
@@ -110,5 +109,63 @@ const checkStoreIsSupported = (storage: PostHogStorage, key = '__mplssupport__')
   }
 }
 
-export const localStore = checkStoreIsSupported(_localStore) ? _localStore : undefined
-export const sessionStorage = checkStoreIsSupported(_sessionStore) ? _sessionStore : undefined
+let localStore: PostHogStorage | undefined = undefined
+let sessionStore: PostHogStorage | undefined = undefined
+
+const createMemoryStorage = (): PostHogStorage => {
+  const _cache: { [key: string]: any | undefined } = {}
+
+  const store: PostHogStorage = {
+    getItem(key) {
+      return _cache[key]
+    },
+
+    setItem(key, value) {
+      _cache[key] = value !== null ? value : undefined
+    },
+
+    removeItem(key) {
+      delete _cache[key]
+    },
+    clear() {
+      for (const key in _cache) {
+        delete _cache[key]
+      }
+    },
+    getAllKeys() {
+      const keys = []
+      for (const key in _cache) {
+        keys.push(key)
+      }
+      return keys
+    },
+  }
+  return store
+}
+
+export const getStorage = (type: PostHogOptions['persistence'], window: Window | undefined): PostHogStorage => {
+  if (window) {
+    if (!localStorage) {
+      const _localStore = createStorageLike(window.localStorage)
+      localStore = checkStoreIsSupported(_localStore) ? _localStore : undefined
+    }
+
+    if (!sessionStore) {
+      const _sessionStore = createStorageLike(window.sessionStorage)
+      sessionStore = checkStoreIsSupported(_sessionStore) ? _sessionStore : undefined
+    }
+  }
+
+  switch (type) {
+    case 'cookie':
+      return cookieStore || localStore || sessionStore || createMemoryStorage()
+    case 'localStorage':
+      return localStore || sessionStore || createMemoryStorage()
+    case 'sessionStorage':
+      return sessionStore || createMemoryStorage()
+    case 'memory':
+      return createMemoryStorage()
+    default:
+      return createMemoryStorage()
+  }
+}

package/src/types.ts

@@ -0,0 +1,7 @@
+import { PosthogCoreOptions } from '../../posthog-core/src'
+
+export type PostHogOptions = {
+  autocapture?: boolean
+  persistence?: 'localStorage' | 'sessionStorage' | 'cookie' | 'memory'
+  persistence_name?: string
+} & PosthogCoreOptions