@posthog/browser-common 0.0.0 → 0.2.0

package/dist/pubsub.d.ts

@@ -0,0 +1,28 @@
+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
+ * event carries its own payload type. The handler is called synchronously for
+ * each future payload, and the returned disposable unregisters it.
+ */
+export type Listener<T> = (handler: (payload: T) => void) => Disposable;
+/**
+ * Publish/subscribe helper for client events exposed to extensions. A client
+ * owns the publisher, calls {@link Publisher.publish} to fire payloads, and
+ * exposes only {@link Publisher.listener} to extensions so they can subscribe
+ * without gaining publish access. Calling {@link Publisher.dispose} drops all
+ * listeners.
+ */
+export declare class Publisher<T> implements Disposable {
+    /** Subscriptions currently registered with this publisher. */
+    private _subscriptions;
+    /**
+     * Register a handler for future payloads. The returned disposable
+     * subscription unregisters this handler.
+     */
+    readonly listener: Listener<T>;
+    /** Notify every currently registered listener with the provided payload. */
+    publish(payload: T): void;
+    /** Drop all registered listeners. Safe to call more than once. */
+    dispose(): void;
+}

package/dist/pubsub.js

@@ -0,0 +1,67 @@
+"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__, {
+    Publisher: ()=>Publisher
+});
+class Publisher {
+    publish(payload) {
+        const subscriptions = this._subscriptions.slice();
+        subscriptions.forEach((subscription)=>{
+            if (subscription.isActive) subscription.handler(payload);
+        });
+    }
+    dispose() {
+        this._subscriptions.forEach((subscription)=>{
+            subscription.isActive = false;
+        });
+        this._subscriptions = [];
+    }
+    constructor(){
+        this._subscriptions = [];
+        this.listener = (handler)=>{
+            const subscription = {
+                handler,
+                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);
+                }
+            };
+        };
+    }
+}
+exports.Publisher = __webpack_exports__.Publisher;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "Publisher"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/pubsub.mjs

@@ -0,0 +1,33 @@
+class Publisher {
+    publish(payload) {
+        const subscriptions = this._subscriptions.slice();
+        subscriptions.forEach((subscription)=>{
+            if (subscription.isActive) subscription.handler(payload);
+        });
+    }
+    dispose() {
+        this._subscriptions.forEach((subscription)=>{
+            subscription.isActive = false;
+        });
+        this._subscriptions = [];
+    }
+    constructor(){
+        this._subscriptions = [];
+        this.listener = (handler)=>{
+            const subscription = {
+                handler,
+                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);
+                }
+            };
+        };
+    }
+}
+export { Publisher };

package/dist/token.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A typed, implementation-free key 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' }
+ * ```
+ *
+ * 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.
+ */
+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;
+}

package/dist/token.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
+});

package/dist/utils/array-at-polyfill.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/array-at-polyfill.js

@@ -0,0 +1,16 @@
+var __webpack_exports__ = {};
+if ('function' != typeof Array.prototype.at) Object.defineProperty(Array.prototype, 'at', {
+    value: function(index) {
+        const len = this.length;
+        let relativeIndex = Math.trunc(index) || 0;
+        if (relativeIndex < 0) relativeIndex += len;
+        return relativeIndex < 0 || relativeIndex >= len ? void 0 : this[relativeIndex];
+    },
+    writable: true,
+    enumerable: false,
+    configurable: true
+});
+for(var __webpack_i__ in __webpack_exports__)exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/utils/array-at-polyfill.mjs

@@ -0,0 +1,11 @@
+if ('function' != typeof Array.prototype.at) Object.defineProperty(Array.prototype, 'at', {
+    value: function(index) {
+        const len = this.length;
+        let relativeIndex = Math.trunc(index) || 0;
+        if (relativeIndex < 0) relativeIndex += len;
+        return relativeIndex < 0 || relativeIndex >= len ? void 0 : this[relativeIndex];
+    },
+    writable: true,
+    enumerable: false,
+    configurable: true
+});

package/dist/utils/autocapture-utils.d.ts

@@ -0,0 +1,23 @@
+import type { AutocaptureConfig, PostHogConfig, Properties } from '@posthog/types';
+import { type UrlTargetingInstance } from './url-targeting-utils';
+export declare const MAX_DOM_ANCESTOR_DEPTH = 1000;
+export declare function splitClassString(s: string): string[];
+export declare function getClassNames(el: Element): string[];
+export declare function makeSafeText(s: string | null | undefined): string | null;
+export declare function getSafeText(el: Element): string;
+export declare function getEventTarget(e: Event): Element | null;
+export declare const autocaptureCompatibleElements: string[];
+export declare function getParentElement(curEl: Element): Element | false;
+export declare const DEFAULT_CONTENT_IGNORELIST_WITH_STEPPERS: string[];
+export declare function shouldCaptureDeadClick(el: Element | null, _config: PostHogConfig['capture_dead_clicks']): boolean;
+export declare function isTextSelectionTarget(el: Element | null): boolean;
+export declare function shouldCaptureRageclick(el: Element | null, _config: PostHogConfig['rageclick']): boolean;
+export declare function shouldSkipDeadClick(el: Element | null): boolean;
+export declare function shouldCaptureDomEvent(el: Element, event: Event, autocaptureConfig?: AutocaptureConfig | undefined, captureOnAnyElement?: boolean, allowedEventTypes?: string[], instance?: UrlTargetingInstance): boolean;
+export declare function shouldCaptureElement(el: Element): boolean;
+export declare function isSensitiveElement(el: Element): boolean;
+export declare function shouldCaptureValue(value: string, anchorRegexes?: boolean): boolean;
+export declare function isAngularStyleAttr(attributeName: string): boolean;
+export declare function getDirectAndNestedSpanText(target: Element): string;
+export declare function getNestedSpanText(target: Element): string;
+export declare function getElementsChainString(elements: Properties[]): string;