@posthog/browser-common 0.2.0 → 0.2.2

package/dist/extension-runtime.mjs

@@ -0,0 +1,75 @@
+import { isFunction } from "@posthog/core";
+class ExtensionRuntime {
+    constructor(_logger){
+        this._logger = _logger;
+        this._extensions = new Map();
+        this._registrationOrder = [];
+        this._providerReservations = new Map();
+        this._providers = new Map();
+    }
+    async add(extension, client) {
+        if (this._disposePromise) throw new Error('Cannot add an extension to a disposed ExtensionRuntime');
+        if (this._extensions.has(extension.name)) throw new Error(`Browser extension "${extension.name}" is already registered`);
+        for (const token of extension.provides ?? [])if (this._providerReservations.has(token)) throw new Error(`Browser extension token "${token}" is already registered`);
+        const registered = {
+            extension,
+            setupPromise: Promise.resolve()
+        };
+        this._extensions.set(extension.name, registered);
+        this._registrationOrder.push(registered);
+        for (const token of extension.provides ?? [])this._providerReservations.set(token, registered);
+        let setupResult;
+        try {
+            setupResult = extension.setup(client);
+        } catch (error) {
+            registered.setupPromise = this._handleSetupFailure(registered, error);
+            return registered.setupPromise;
+        }
+        if (setupResult && isFunction(setupResult.then)) registered.setupPromise = setupResult.then(()=>this._publishRegistration(registered)).catch((error)=>this._handleSetupFailure(registered, error));
+        else this._publishRegistration(registered);
+        return registered.setupPromise;
+    }
+    getExtension(token) {
+        return this._providers.get(token);
+    }
+    dispose() {
+        if (!this._disposePromise) this._disposePromise = this._disposeAll();
+        return this._disposePromise;
+    }
+    async _disposeAll() {
+        for (const registered of this._registrationOrder.slice().reverse()){
+            await registered.setupPromise;
+            await this._disposeRegistration(registered);
+        }
+        this._extensions.clear();
+        this._registrationOrder.length = 0;
+        this._providerReservations.clear();
+        this._providers.clear();
+    }
+    async _handleSetupFailure(registered, error) {
+        this._removeRegistration(registered);
+        this._logger.error(`Failed to set up browser extension "${registered.extension.name}"`, error);
+        if (this._disposePromise) return;
+        await this._disposeRegistration(registered);
+        const index = this._registrationOrder.indexOf(registered);
+        if (-1 !== index) this._registrationOrder.splice(index, 1);
+    }
+    _disposeRegistration(registered) {
+        if (!registered.disposalPromise) registered.disposalPromise = Promise.resolve().then(()=>registered.extension.dispose()).catch((error)=>{
+            this._logger.error(`Failed to dispose browser extension "${registered.extension.name}"`, error);
+        });
+        return registered.disposalPromise;
+    }
+    _removeRegistration(registered) {
+        if (this._extensions.get(registered.extension.name) === registered) this._extensions.delete(registered.extension.name);
+        for (const token of registered.extension.provides ?? []){
+            if (this._providerReservations.get(token) === registered) this._providerReservations.delete(token);
+            if (this._providers.get(token) === registered.extension) this._providers.delete(token);
+        }
+    }
+    _publishRegistration(registered) {
+        if (this._disposePromise || this._extensions.get(registered.extension.name) !== registered) return;
+        for (const token of registered.extension.provides ?? [])this._providers.set(token, registered.extension);
+    }
+}
+export { ExtensionRuntime };

package/dist/index.d.ts

@@ -3,9 +3,12 @@
  * clients.
  */
 export type { Extension } from './extension';
-export type { Disposable } from './disposable';
+export { CoreExtension } from './core-extension';
+export type { DeepReadonly, SessionContext, NewSessionReason, NewSessionInfo, CapturedEventInfo, CaptureOptions, } from './core-extension';
+export * from './types';
+export { createDisposable, type Disposable } from './disposable';
 export type { ExtensionToken } from './token';
 export type { Listener } from './pubsub';
 export { Publisher } from './pubsub';
-export type { Client, SessionContext, NewSessionReason, NewSessionInfo, CapturedEventInfo, CaptureOptions, ApiResponse, ApiRequestInit, RemoteConfig, } from './client';
+export type { Client, ApiResponse, ApiRequestInit } from './client';
 export type { KeyValueStore } from './persistence';

package/dist/index.js

@@ -1,5 +1,37 @@
 "use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./core-extension": function(module) {
+        module.exports = require("./core-extension.js");
+    },
+    "./disposable": function(module) {
+        module.exports = require("./disposable.js");
+    },
+    "./pubsub": function(module) {
+        module.exports = require("./pubsub.js");
+    },
+    "./types": function(module) {
+        module.exports = require("./types/index.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
 (()=>{
     __webpack_require__.d = (exports1, definition)=>{
         for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
@@ -22,14 +54,35 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    Publisher: ()=>external_pubsub_js_namespaceObject.Publisher
-});
-const external_pubsub_js_namespaceObject = require("./pubsub.js");
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        CoreExtension: ()=>_core_extension__WEBPACK_IMPORTED_MODULE_0__.CoreExtension,
+        Publisher: ()=>_pubsub__WEBPACK_IMPORTED_MODULE_3__.Publisher,
+        createDisposable: ()=>_disposable__WEBPACK_IMPORTED_MODULE_2__.createDisposable
+    });
+    var _core_extension__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./core-extension");
+    var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./types");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _types__WEBPACK_IMPORTED_MODULE_1__)if ([
+        "createDisposable",
+        "default",
+        "CoreExtension",
+        "Publisher"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _types__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _disposable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./disposable");
+    var _pubsub__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./pubsub");
+})();
+exports.CoreExtension = __webpack_exports__.CoreExtension;
 exports.Publisher = __webpack_exports__.Publisher;
+exports.createDisposable = __webpack_exports__.createDisposable;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "Publisher"
+    "CoreExtension",
+    "Publisher",
+    "createDisposable"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/index.mjs

@@ -1,2 +1,5 @@
+import { CoreExtension } from "./core-extension.mjs";
+import { createDisposable } from "./disposable.mjs";
 import { Publisher } from "./pubsub.mjs";
-export { Publisher };
+export * from "./types/index.mjs";
+export { CoreExtension, Publisher, createDisposable };

package/dist/persistence.d.ts

@@ -1,11 +1,14 @@
 /**
- * Async key-value store for small extension state. Backed by whatever the
- * client provides — a synchronous store resolves immediately, an asynchronous
- * one (e.g. IndexedDB) does real I/O — so reads and writes are always awaited.
+ * Key-value store for small extension state. Implementations backed by
+ * synchronous persistence may return immediately, while asynchronous stores
+ * (for example IndexedDB) may return promises. Consumers can await either.
  *
- * The store is namespaced to the client instance, so keys are local to the
- * extension and never collide with core SDK state. Values must be
- * JSON-serializable; setting `null`/`undefined` removes the key.
+ * Keys map verbatim to the host client's shared persistence. In browser-v1,
+ * unknown keys are normally included as event properties, collisions overwrite
+ * host/core state, and reset clears them. Every SDK-owned key therefore needs an
+ * explicit event/hidden/derived exposure policy in each host, and sensitive data
+ * must not be stored unless its transmission is approved. Values must be
+ * JSON-serializable.
  */
 export interface KeyValueStore {
     /**
@@ -13,12 +16,12 @@ export interface KeyValueStore {
      *
      * @returns The stored value, or `undefined` when the key is missing.
      */
-    get<T = unknown>(key: string): Promise<T | undefined>;
+    get<T = unknown>(key: string): T | undefined | Promise<T | undefined>;
     /**
-     * Store a JSON-serializable value by key. Passing `null` or `undefined`
-     * removes the key instead of persisting that value.
+     * Forward a JSON-serializable value, including nullish values, to the host's
+     * native persistence. `undefined` is not portable or durable storage.
      */
-    set(key: string, value: unknown): Promise<void>;
-    /** Remove a value by key. Resolves successfully when the key is already absent. */
-    remove(key: string): Promise<void>;
+    set(key: string, value: unknown): void | Promise<void>;
+    /** Remove a value by key. This is the portable deletion operation. */
+    remove(key: string): void | Promise<void>;
 }

package/dist/pubsub.d.ts

@@ -1,4 +1,4 @@
-import type { Disposable } from './disposable';
+import { type Disposable } from './disposable';
 /**
  * Call it with a handler to start listening; dispose the returned
  * {@link Disposable} to stop. There is one `Listener` per event type, so every

package/dist/pubsub.js

@@ -26,6 +26,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     Publisher: ()=>Publisher
 });
+const external_disposable_js_namespaceObject = require("./disposable.js");
 class Publisher {
     publish(payload) {
         const subscriptions = this._subscriptions.slice();
@@ -47,14 +48,11 @@ class Publisher {
                 isActive: true
             };
             this._subscriptions.push(subscription);
-            return {
-                dispose: ()=>{
-                    if (!subscription.isActive) return;
-                    subscription.isActive = false;
-                    const index = this._subscriptions.indexOf(subscription);
-                    if (-1 !== index) this._subscriptions.splice(index, 1);
-                }
-            };
+            return (0, external_disposable_js_namespaceObject.createDisposable)(()=>{
+                subscription.isActive = false;
+                const index = this._subscriptions.indexOf(subscription);
+                if (-1 !== index) this._subscriptions.splice(index, 1);
+            });
         };
     }
 }

package/dist/pubsub.mjs

@@ -1,3 +1,4 @@
+import { createDisposable } from "./disposable.mjs";
 class Publisher {
     publish(payload) {
         const subscriptions = this._subscriptions.slice();
@@ -19,14 +20,11 @@ class Publisher {
                 isActive: true
             };
             this._subscriptions.push(subscription);
-            return {
-                dispose: ()=>{
-                    if (!subscription.isActive) return;
-                    subscription.isActive = false;
-                    const index = this._subscriptions.indexOf(subscription);
-                    if (-1 !== index) this._subscriptions.splice(index, 1);
-                }
-            };
+            return createDisposable(()=>{
+                subscription.isActive = false;
+                const index = this._subscriptions.indexOf(subscription);
+                if (-1 !== index) this._subscriptions.splice(index, 1);
+            });
         };
     }
 }

package/dist/token.d.ts

@@ -1,21 +1,22 @@
+/** Phantom brand carrying the capability type without emitting runtime code. */
+declare const extensionTokenType: unique symbol;
 /**
- * A typed, implementation-free key for resolving an extension that provides a
- * capability. Declared as a shared `const` next to the providing extension's
+ * A typed, implementation-free string for resolving an extension that provides
+ * a capability. Declared as a shared `const` next to the providing extension's
  * interface:
  *
  * ```ts
  * export interface FeatureFlagsExtension extends Extension { … }
- * export const FeatureFlags: ExtensionToken<FeatureFlagsExtension> = { name: 'featureFlags' }
+ * export const FeatureFlags = 'posthog.featureFlags' as ExtensionToken<FeatureFlagsExtension>
  * ```
  *
  * A token holds no implementation, so importing one never pulls the provider's
- * code into the consumer's bundle. The registry is keyed by token identity
- * (the shared object reference), so provider and consumer must import the same
- * exported token; `name` is for diagnostics only.
+ * code into the consumer's bundle. Its generic brand lets `getExtension` infer
+ * the provided type, while its runtime string value remains stable across
+ * independently compiled scripts. Token strings must be globally unique and
+ * stable for the lifetime of the capability contract.
  */
-export interface ExtensionToken<T> {
-    /** Human-readable capability name used only for diagnostics. */
-    readonly name: string;
-    /** Phantom: carries the provided type for inference; never present at runtime. */
-    readonly __provides?: T;
-}
+export type ExtensionToken<T> = string & {
+    readonly [extensionTokenType]: T;
+};
+export {};

package/dist/types/compression.d.ts

@@ -0,0 +1,5 @@
+export declare const Compression: {
+    readonly GZipJS: "gzip-js";
+    readonly Base64: "base64";
+};
+export type Compression = (typeof Compression)[keyof typeof Compression];

package/dist/types/compression.js

@@ -0,0 +1,39 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Compression: ()=>Compression
+});
+const Compression = {
+    GZipJS: 'gzip-js',
+    Base64: 'base64'
+};
+exports.Compression = __webpack_exports__.Compression;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Compression"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/compression.mjs

@@ -0,0 +1,5 @@
+const Compression = {
+    GZipJS: 'gzip-js',
+    Base64: 'base64'
+};
+export { Compression };

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './compression';
+export * from './network-recording';
+export * from './remote-config';
+export * from './surveys';

package/dist/types/index.js

@@ -0,0 +1,87 @@
+"use strict";
+var __webpack_modules__ = {
+    "./compression": function(module) {
+        module.exports = require("./compression.js");
+    },
+    "./network-recording": function(module) {
+        module.exports = require("./network-recording.js");
+    },
+    "./remote-config": function(module) {
+        module.exports = require("./remote-config.js");
+    },
+    "./surveys": function(module) {
+        module.exports = require("./surveys.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _compression__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./compression");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _compression__WEBPACK_IMPORTED_MODULE_0__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _compression__WEBPACK_IMPORTED_MODULE_0__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _network_recording__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./network-recording");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _network_recording__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _network_recording__WEBPACK_IMPORTED_MODULE_1__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _remote_config__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./remote-config");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _remote_config__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _remote_config__WEBPACK_IMPORTED_MODULE_2__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _surveys__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./surveys");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _surveys__WEBPACK_IMPORTED_MODULE_3__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _surveys__WEBPACK_IMPORTED_MODULE_3__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+})();
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/types/index.mjs

@@ -0,0 +1,4 @@
+export * from "./compression.mjs";
+export * from "./network-recording.mjs";
+export * from "./remote-config.mjs";
+export * from "./surveys.mjs";

package/dist/types/network-recording.d.ts

@@ -0,0 +1,42 @@
+import type { CapturedNetworkRequest, InitiatorType } from '@posthog/types';
+export type NetworkRecordOptions = {
+    initiatorTypes?: InitiatorType[];
+    maskRequestFn?: (data: CapturedNetworkRequest) => CapturedNetworkRequest | undefined;
+    recordHeaders?: boolean | {
+        request: boolean;
+        response: boolean;
+    };
+    recordBody?: boolean | string[] | {
+        request: boolean | string[];
+        response: boolean | string[];
+    };
+    recordInitialRequests?: boolean;
+    /**
+     * whether to record PerformanceEntry events for network requests
+     */
+    recordPerformance?: boolean;
+    /**
+     * the PerformanceObserver will only observe these entry types
+     */
+    performanceEntryTypeToObserve: string[];
+    /**
+     * the maximum size of the request/response body to record
+     * NB this will be at most 1MB even if set larger
+     */
+    payloadSizeLimitBytes: number;
+    /**
+     * when true, read bodies through a streaming reader that stops at payloadSizeLimitBytes
+     * instead of buffering the whole body and then enforcing the limit. Reads only a clone of
+     * the body, so it never consumes the stream the page itself reads.
+     * @default false
+     */
+    streamNetworkBody?: boolean;
+    /**
+     * some domains we should never record the payload
+     * for example other companies session replay ingestion payloads aren't super useful but are gigantic
+     * if this isn't provided we use a default list
+     * if this is provided - we add the provided list to the default list
+     * i.e. we never record the payloads on the default deny list
+     */
+    payloadHostDenyList?: string[];
+};

package/dist/types/network-recording.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});