@leanbase.com/js 0.1.0

package/src/leanbase.ts

@@ -0,0 +1,129 @@
+import { PostHogCore, getFetch } from '@posthog/core'
+import type {
+    PostHogCoreOptions,
+    PostHogEventProperties,
+    PostHogFetchOptions,
+    PostHogFetchResponse,
+    PostHogPersistedProperty,
+    PostHogCaptureOptions,
+} from '@posthog/core'
+import { version } from './version'
+import { logger } from './leanbase-logger'
+import { isNull } from '@posthog/core'
+
+export interface LeanbaseOptions extends Partial<PostHogCoreOptions> {
+    /**
+     * Enable autocapture of clicks and form interactions
+     * @default true
+     */
+    autocapture?: boolean
+
+    /**
+     * API host for Leanbase
+     * @default 'https://i.leanbase.co'
+     */
+    host?: string
+}
+
+export class Leanbase extends PostHogCore {
+    private _storage: Map<string, any> = new Map()
+    private _storageKey: string
+
+    constructor(apiKey: string, options?: LeanbaseOptions) {
+        // Leanbase defaults
+        const leanbaseOptions: PostHogCoreOptions = {
+            host: 'https://i.leanbase.co',
+            ...options,
+        }
+
+        super(apiKey, leanbaseOptions)
+
+        this._storageKey = `leanbase_${apiKey}`
+
+        // Load from localStorage if available
+        if (typeof window !== 'undefined' && window.localStorage) {
+            try {
+                const stored = window.localStorage.getItem(this._storageKey)
+                if (stored) {
+                    const parsed = JSON.parse(stored)
+                    Object.entries(parsed).forEach(([key, value]) => {
+                        this._storage.set(key, value)
+                    })
+                }
+            } catch (err) {
+                logger.warn('Failed to load persisted data', err)
+            }
+        }
+
+        logger.info('Leanbase initialized', { apiKey, host: leanbaseOptions.host })
+
+        // Preload feature flags if not explicitly disabled
+        if (options?.preloadFeatureFlags !== false) {
+            this.reloadFeatureFlags()
+        }
+    }
+
+    // PostHogCore abstract methods
+    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> {
+        const fetchFn = getFetch()
+
+        if (!fetchFn) {
+            return Promise.reject(new Error('Fetch API is not available in this environment.'))
+        }
+
+        return fetchFn(url, options)
+    }
+
+    getLibraryId(): string {
+        return 'leanbase'
+    }
+
+    getLibraryVersion(): string {
+        return version
+    }
+
+    getCustomUserAgent(): void {
+        return
+    }
+
+    getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined {
+        return this._storage.get(key)
+    }
+
+    setPersistedProperty<T>(key: PostHogPersistedProperty, value: T | null): void {
+        if (isNull(value)) {
+            this._storage.delete(key)
+        } else {
+            this._storage.set(key, value)
+        }
+
+        // Persist to localStorage if available
+        if (typeof window !== 'undefined' && window.localStorage) {
+            try {
+                const obj: Record<string, any> = {}
+                this._storage.forEach((v, k) => {
+                    obj[k] = v
+                })
+                window.localStorage.setItem(this._storageKey, JSON.stringify(obj))
+            } catch (err) {
+                logger.warn('Failed to persist data', err)
+            }
+        }
+    }
+
+    // Public API: leanbase.capture()
+    capture(event: string, properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void {
+        super.capture(event, properties, options)
+    }
+
+    // Public API: leanbase.identify()
+    identify(distinctId?: string, properties?: PostHogEventProperties, options?: PostHogCaptureOptions): void {
+        super.identify(distinctId, properties, options)
+    }
+
+    // Cleanup
+    destroy(): void {
+        // Future: cleanup autocapture and session recording
+        this._storage.clear()
+    }
+}

package/src/version.ts

@@ -0,0 +1 @@
+export const version = '0.1.0'