@posthog/browser-common 0.9.3 → 0.9.5

package/dist/extension-tokens.js

@@ -0,0 +1,40 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__);
+const FeatureFlagsCommonExtension = 'featureFlagsCommon';
+__webpack_require__.d(__webpack_exports__, {}, {
+    FeatureFlagsCommonExtension: FeatureFlagsCommonExtension
+});
+exports.FeatureFlagsCommonExtension = __webpack_exports__.FeatureFlagsCommonExtension;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FeatureFlagsCommonExtension"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/extension-tokens.mjs

@@ -0,0 +1,2 @@
+const FeatureFlagsCommonExtension = 'featureFlagsCommon';
+export { FeatureFlagsCommonExtension };

package/dist/extension.d.ts

@@ -23,11 +23,15 @@ import type { Client } from './client';
 export interface Extension {
     /** Stable extension name used for diagnostics and de-duplication within a client instance. */
     readonly name: string;
+    /** Additional lookup targets whose lifecycle belongs to this extension. */
+    readonly bindings?: Readonly<Record<string, Extension>>;
     /**
      * Start the extension with the host client's capability surface. Called once
      * after construction; return a promise when setup needs asynchronous state.
      */
     setup(client: Client): void | Promise<void>;
+    /** Flush buffered work. Shutdown awaits this within the host's timeout before disposal. */
+    flush?(reason?: 'flush' | 'shutdown'): Promise<void>;
     /** Release final resources synchronously. Feature-level start/stop remains extension-owned. */
     dispose?(): void;
 }

package/dist/feature-flags.js

@@ -797,7 +797,7 @@ class PostHogFeatureFlags {
         let flagCallReported = this._prop(external_constants_js_namespaceObject.FLAG_CALL_REPORTED) || {};
         let sessionIdToPersist;
         if (this._config.deduplicateCallsPerSession) {
-            const currentSessionId = this._client?.session.sessionId;
+            const currentSessionId = this._client?.session?.sessionId;
             const storedSessionId = this._prop(external_constants_js_namespaceObject.FLAG_CALL_REPORTED_SESSION_ID);
             if (currentSessionId && currentSessionId !== storedSessionId) {
                 flagCallReported = {};

package/dist/feature-flags.mjs

@@ -761,7 +761,7 @@ class PostHogFeatureFlags {
         let flagCallReported = this._prop(FLAG_CALL_REPORTED) || {};
         let sessionIdToPersist;
         if (this._config.deduplicateCallsPerSession) {
-            const currentSessionId = this._client?.session.sessionId;
+            const currentSessionId = this._client?.session?.sessionId;
             const storedSessionId = this._prop(FLAG_CALL_REPORTED_SESSION_ID);
             if (currentSessionId && currentSessionId !== storedSessionId) {
                 flagCallReported = {};

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  */
 export type { Extension } from './extension';
 export type { ExtensionToken } from './token';
+export { FeatureFlagsCommonExtension } from './extension-tokens';
 export * from './types';
 export { createDisposable, type Disposable } from './disposable';
 export type { Listener } from './pubsub';

package/dist/index.js

@@ -3,6 +3,9 @@ var __webpack_modules__ = {
     "./disposable" (module) {
         module.exports = require("./disposable.js");
     },
+    "./extension-tokens" (module) {
+        module.exports = require("./extension-tokens.js");
+    },
     "./pubsub" (module) {
         module.exports = require("./pubsub.js");
     },
@@ -57,24 +60,29 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _types__rspack_import_0 = __webpack_require__("./types");
+    var _extension_tokens__rspack_import_0 = __webpack_require__("./extension-tokens");
+    var _types__rspack_import_1 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_0)if ([
+    for(const __rspack_import_key in _types__rspack_import_1)if ([
         "Publisher",
         "createDisposable",
+        "FeatureFlagsCommonExtension",
         "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_0[__rspack_import_key];
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _disposable__rspack_import_1 = __webpack_require__("./disposable");
-    var _pubsub__rspack_import_2 = __webpack_require__("./pubsub");
+    var _disposable__rspack_import_2 = __webpack_require__("./disposable");
+    var _pubsub__rspack_import_3 = __webpack_require__("./pubsub");
     __webpack_require__.d(__webpack_exports__, {
-        Publisher: ()=>_pubsub__rspack_import_2.Publisher,
-        createDisposable: ()=>_disposable__rspack_import_1.createDisposable
+        FeatureFlagsCommonExtension: ()=>_extension_tokens__rspack_import_0.FeatureFlagsCommonExtension,
+        Publisher: ()=>_pubsub__rspack_import_3.Publisher,
+        createDisposable: ()=>_disposable__rspack_import_2.createDisposable
     });
 })();
+exports.FeatureFlagsCommonExtension = __webpack_exports__.FeatureFlagsCommonExtension;
 exports.Publisher = __webpack_exports__.Publisher;
 exports.createDisposable = __webpack_exports__.createDisposable;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FeatureFlagsCommonExtension",
     "Publisher",
     "createDisposable"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/index.mjs

@@ -1,3 +1,4 @@
 export * from "./types/index.mjs";
+export { FeatureFlagsCommonExtension } from "./extension-tokens.mjs";
 export { createDisposable } from "./disposable.mjs";
 export { Publisher } from "./pubsub.mjs";

package/dist/logs-config.d.ts

@@ -0,0 +1,24 @@
+import type { LogCaptureOptions } from '@posthog/types';
+import type { ResolvedPostHogLogsConfig } from '@posthog/core';
+export interface BrowserLogsConfig extends LogCaptureOptions {
+    captureConsoleLogs?: boolean;
+}
+/** SDK configuration mapping; values are read again when configuration changes. */
+export interface LogsConfigSource {
+    get(): BrowserLogsConfig | undefined;
+    readonly captureHintKey: string;
+    readonly remoteConfigWillArrive: boolean;
+}
+/**
+ * Resolves the public `logs` config into the shape core `PostHogLogs` consumes.
+ *
+ * `serviceNameDefault` is the console instance's `service.name` fallback
+ * (`posthog-browser-logs`); the programmatic instance falls back to core's
+ * `unknown_service`. `consoleCapture` disables the per-interval rate cap entirely
+ * (even when the user set `maxLogsPerInterval`), so console capture is never
+ * rate-dropped — the deep buffer is its only bound.
+ */
+export declare function resolveLogsConfig(config: LogCaptureOptions | undefined, opts?: {
+    serviceNameDefault?: string;
+    consoleCapture?: boolean;
+}): ResolvedPostHogLogsConfig;

package/dist/logs-config.js

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__, {
+    resolveLogsConfig: ()=>resolveLogsConfig
+});
+const core_namespaceObject = require("@posthog/core");
+const DEFAULT_FLUSH_INTERVAL_MS = 3000;
+const DEFAULT_MAX_BUFFER_SIZE = 100;
+const DEFAULT_MAX_LOGS_PER_INTERVAL = 1000;
+const DEFAULT_CONSOLE_MAX_QUEUE_SIZE = 2048;
+const DEFAULT_MAX_BATCH_RECORDS_PER_POST = 100;
+function defaultResourceAttributes() {
+    let osName = '';
+    let osVersion = '';
+    try {
+        const browserGlobal = "u" > typeof globalThis ? globalThis : "u" > typeof window ? window : void 0;
+        const userAgent = browserGlobal?.navigator?.userAgent;
+        if (userAgent) [osName, osVersion] = (0, core_namespaceObject.detectOS)(userAgent);
+    } catch  {}
+    return (0, core_namespaceObject.osResourceAttributes)(osName, osVersion);
+}
+function resolveLogsConfig(config, opts) {
+    const flushIntervalMs = config?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    const maxBufferSize = config?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+    const maxLogsPerInterval = opts?.consoleCapture ? void 0 : config?.maxLogsPerInterval ?? DEFAULT_MAX_LOGS_PER_INTERVAL;
+    const maxQueueSize = (0, core_namespaceObject.isUndefined)(maxLogsPerInterval) ? Math.max(maxBufferSize, DEFAULT_CONSOLE_MAX_QUEUE_SIZE) : Math.max(maxBufferSize, maxLogsPerInterval);
+    const resourceAttributes = {
+        ...defaultResourceAttributes(),
+        ...config?.resourceAttributes
+    };
+    return {
+        serviceName: resourceAttributes?.['service.name'] ?? config?.serviceName ?? opts?.serviceNameDefault,
+        serviceVersion: resourceAttributes?.['service.version'] ?? config?.serviceVersion,
+        environment: resourceAttributes?.['deployment.environment'] ?? config?.environment,
+        resourceAttributes,
+        beforeSend: config?.beforeSend,
+        flushIntervalMs,
+        maxBufferSize,
+        maxQueueSize,
+        maxBatchRecordsPerPost: DEFAULT_MAX_BATCH_RECORDS_PER_POST,
+        rateCapWindowMs: flushIntervalMs,
+        maxLogsPerInterval,
+        backgroundFlushBudgetMs: 0,
+        terminationFlushBudgetMs: 0
+    };
+}
+exports.resolveLogsConfig = __webpack_exports__.resolveLogsConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveLogsConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/logs-config.mjs

@@ -0,0 +1,42 @@
+import { detectOS, isUndefined, osResourceAttributes } from "@posthog/core";
+const DEFAULT_FLUSH_INTERVAL_MS = 3000;
+const DEFAULT_MAX_BUFFER_SIZE = 100;
+const DEFAULT_MAX_LOGS_PER_INTERVAL = 1000;
+const DEFAULT_CONSOLE_MAX_QUEUE_SIZE = 2048;
+const DEFAULT_MAX_BATCH_RECORDS_PER_POST = 100;
+function defaultResourceAttributes() {
+    let osName = '';
+    let osVersion = '';
+    try {
+        const browserGlobal = "u" > typeof globalThis ? globalThis : "u" > typeof window ? window : void 0;
+        const userAgent = browserGlobal?.navigator?.userAgent;
+        if (userAgent) [osName, osVersion] = detectOS(userAgent);
+    } catch  {}
+    return osResourceAttributes(osName, osVersion);
+}
+function resolveLogsConfig(config, opts) {
+    const flushIntervalMs = config?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    const maxBufferSize = config?.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE;
+    const maxLogsPerInterval = opts?.consoleCapture ? void 0 : config?.maxLogsPerInterval ?? DEFAULT_MAX_LOGS_PER_INTERVAL;
+    const maxQueueSize = isUndefined(maxLogsPerInterval) ? Math.max(maxBufferSize, DEFAULT_CONSOLE_MAX_QUEUE_SIZE) : Math.max(maxBufferSize, maxLogsPerInterval);
+    const resourceAttributes = {
+        ...defaultResourceAttributes(),
+        ...config?.resourceAttributes
+    };
+    return {
+        serviceName: resourceAttributes?.['service.name'] ?? config?.serviceName ?? opts?.serviceNameDefault,
+        serviceVersion: resourceAttributes?.['service.version'] ?? config?.serviceVersion,
+        environment: resourceAttributes?.['deployment.environment'] ?? config?.environment,
+        resourceAttributes,
+        beforeSend: config?.beforeSend,
+        flushIntervalMs,
+        maxBufferSize,
+        maxQueueSize,
+        maxBatchRecordsPerPost: DEFAULT_MAX_BATCH_RECORDS_PER_POST,
+        rateCapWindowMs: flushIntervalMs,
+        maxLogsPerInterval,
+        backgroundFlushBudgetMs: 0,
+        terminationFlushBudgetMs: 0
+    };
+}
+export { resolveLogsConfig };

package/dist/logs-types.d.ts

@@ -0,0 +1,31 @@
+import type { Client } from './client';
+import type { LogSdkContext } from '@posthog/core';
+/**
+ * The console methods both bundles agree on: the main bundle records these, the
+ * entrypoint maps and serializes them. Deriving both sides from this tuple makes
+ * a missing level a compile error rather than a silently unbuffered one.
+ */
+export declare const BUFFERED_CONSOLE_LEVELS: readonly ['debug', 'log', 'warn', 'error', 'info'];
+export type BufferedConsoleLevel = (typeof BUFFERED_CONSOLE_LEVELS)[number];
+/**
+ * A `console.*` call the main bundle recorded before the logs entrypoint was available.
+ *
+ * `args` stay raw so the entrypoint's `stringifyArgsSafely` is the single serializer.
+ * They are also held by reference: an object mutated between the console call and the
+ * replay is serialized in its later state, unlike the live path which serializes inline.
+ *
+ * `context` and `occurredAtMs` are snapshotted at the console call, because identity,
+ * session and feature flags can all change before the replay.
+ */
+export interface BufferedConsoleEntry {
+    level: BufferedConsoleLevel;
+    args: any[];
+    occurredAtMs: number;
+    context: LogSdkContext;
+}
+export interface ConsoleLogsCapture {
+    initialize(client: Client): (() => void) | undefined;
+    replay(client: Client, entries: BufferedConsoleEntry[]): void;
+}
+/** A loader may report its result synchronously. */
+export type ConsoleLogsLoader = (callback: (error: unknown, capture?: ConsoleLogsCapture) => void) => void;

package/dist/logs-types.js

@@ -0,0 +1,46 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > 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__);
+const BUFFERED_CONSOLE_LEVELS = [
+    'debug',
+    'log',
+    'warn',
+    'error',
+    'info'
+];
+__webpack_require__.d(__webpack_exports__, {}, {
+    BUFFERED_CONSOLE_LEVELS: BUFFERED_CONSOLE_LEVELS
+});
+exports.BUFFERED_CONSOLE_LEVELS = __webpack_exports__.BUFFERED_CONSOLE_LEVELS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BUFFERED_CONSOLE_LEVELS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/logs-types.mjs

@@ -0,0 +1,8 @@
+const BUFFERED_CONSOLE_LEVELS = [
+    'debug',
+    'log',
+    'warn',
+    'error',
+    'info'
+];
+export { BUFFERED_CONSOLE_LEVELS };

package/dist/logs.d.ts

@@ -0,0 +1,85 @@
+import type { CaptureLogOptions, Logger } from '@posthog/types';
+import type { RemoteConfigResult } from './types/remote-config';
+import type { LogSdkContext } from '@posthog/core';
+import type { Client, DeepReadonly } from './client';
+import type { Extension } from './extension';
+import type { ConsoleLogsLoader } from './logs-types';
+import { type LogsConfigSource } from './logs-config';
+export declare const RECORDER_MAX_AGE_MS = 30000;
+export declare class PostHogLogs implements Extension {
+    private readonly _configSource;
+    /** Reads host SDK metadata at capture time, including while console calls are buffered. */
+    private readonly _getSdkContext;
+    readonly name: string;
+    private _isLogsEnabled;
+    private _isLoaded;
+    private _isLoading;
+    private _logger;
+    private get _coreLogger();
+    private _queue;
+    private _core;
+    private _resolvedConfig;
+    private _resolvedFrom;
+    private _capture_logger;
+    private _consoleQueue;
+    private _consoleCore;
+    private _consoleLogsDispose;
+    private _consoleResolvedConfig;
+    private _consoleResolvedFrom;
+    private _consecutiveStatusZeroFailures;
+    private _client;
+    private _setupStarted;
+    private _remoteConfigSubscription;
+    private _disposed;
+    private _consoleBuffer;
+    private _consoleRecorderUnpatchers;
+    private _isRecordingConsole;
+    private _consoleRecorderTimeout;
+    private _isRecordingConsoleEntry;
+    private _window;
+    private _listeningForReconnect;
+    constructor(_configSource: LogsConfigSource, 
+    /** Reads host SDK metadata at capture time, including while console calls are buffered. */
+    _getSdkContext: () => LogSdkContext);
+    protected get _isRequestReady(): boolean;
+    protected _getConsoleLoader(): ConsoleLogsLoader | undefined;
+    protected _listenForReconnect(): void;
+    private _onReconnect;
+    private _buildCore;
+    private _getCore;
+    private _getConsoleCore;
+    setup(client: Client): void | Promise<void>;
+    private _finishSetup;
+    dispose(): void;
+    onRemoteConfig(result: DeepReadonly<RemoteConfigResult>): void;
+    reset(): void;
+    captureLog(options: CaptureLogOptions): void;
+    /** @internal */
+    captureConsoleLog(options: CaptureLogOptions): void;
+    /** @internal */
+    captureBufferedConsoleLog(options: CaptureLogOptions, context: LogSdkContext, occurredAtMs: number): void;
+    /**
+     * Releases everything console capture is holding when capturing is turned off: the
+     * pre-load buffer, the `console` patches, and console records already queued — at
+     * that moment rather than whenever the page next writes to the console.
+     *
+     * @internal
+     */
+    _onOptOut(): void;
+    private _stopRecorderStartedByPersistedHint;
+    private _startConsoleRecorder;
+    private _recordConsoleEntry;
+    private _stopConsoleRecorder;
+    private _takeConsoleBuffer;
+    get logger(): Logger;
+    flushLogs(transport?: 'XHR' | 'fetch' | 'sendBeacon'): void;
+    /** Await both product queues without changing the legacy fire-and-forget flush API. */
+    flush(): Promise<void>;
+    private _logFlushError;
+    loadIfEnabled(): void;
+    private _createHost;
+    private _sendLogsBatch;
+    private _trackEndpointReachability;
+    private _flushViaTransport;
+    private _drainQueueViaTransport;
+}