posthog-node 5.0.0-alpha.1 → 5.1.0

package/lib/posthog-node/src/extensions/error-tracking/stack-trace.d.ts

@@ -1,15 +0,0 @@
-import { StackFrame, StackLineParser, StackLineParserFn, StackParser } from './types';
-type GetModuleFn = (filename: string | undefined) => string | undefined;
-/** Node Stack line parser */
-export declare function node(getModule?: GetModuleFn): StackLineParserFn;
-/**
- * Does this filename look like it's part of the app code?
- */
-export declare function filenameIsInApp(filename: string, isNative?: boolean): boolean;
-export declare function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser;
-export declare const defaultStackParser: StackParser;
-/** Creates a function that gets the module name from a filename */
-export declare function createGetModuleFromFilename(basePath?: string, isWindows?: boolean): (filename: string | undefined) => string | undefined;
-export declare function createStackParser(...parsers: StackLineParser[]): StackParser;
-export declare function reverseAndStripFrames(stack: ReadonlyArray<StackFrame>): StackFrame[];
-export {};

package/lib/posthog-node/src/extensions/error-tracking/type-checking.d.ts

@@ -1,7 +0,0 @@
-import { PolymorphicEvent } from './types';
-export declare function isEvent(candidate: unknown): candidate is PolymorphicEvent;
-export declare function isPlainObject(candidate: unknown): candidate is Record<string, unknown>;
-export declare function isError(candidate: unknown): candidate is Error;
-export declare function isInstanceOf(candidate: unknown, base: any): boolean;
-export declare function isErrorEvent(event: unknown): boolean;
-export declare function isBuiltin(candidate: unknown, className: string): boolean;

package/lib/posthog-node/src/extensions/error-tracking/types.d.ts

@@ -1,57 +0,0 @@
-export declare const severityLevels: readonly ["fatal", "error", "warning", "log", "info", "debug"];
-export declare type SeverityLevel = (typeof severityLevels)[number];
-export interface PolymorphicEvent {
-    [key: string]: unknown;
-    readonly type: string;
-    readonly target?: unknown;
-    readonly currentTarget?: unknown;
-}
-export interface EventHint {
-    mechanism?: Partial<Mechanism>;
-    syntheticException?: Error | null;
-}
-export interface ErrorProperties {
-    $exception_list: Exception[];
-    $exception_level?: SeverityLevel;
-    $exception_DOMException_code?: string;
-    $exception_personURL?: string;
-}
-export interface Exception {
-    type?: string;
-    value?: string;
-    mechanism?: Mechanism;
-    module?: string;
-    thread_id?: number;
-    stacktrace?: {
-        frames?: StackFrame[];
-        type: 'raw';
-    };
-}
-export interface Mechanism {
-    handled?: boolean;
-    type?: string;
-    source?: string;
-    synthetic?: boolean;
-}
-export type StackParser = (stack: string, skipFirstLines?: number) => StackFrame[];
-export type StackLineParserFn = (line: string) => StackFrame | undefined;
-export type StackLineParser = [number, StackLineParserFn];
-export interface StackFrame {
-    platform: string;
-    filename?: string;
-    function?: string;
-    module?: string;
-    lineno?: number;
-    colno?: number;
-    abs_path?: string;
-    context_line?: string;
-    pre_context?: string[];
-    post_context?: string[];
-    in_app?: boolean;
-    instruction_addr?: string;
-    addr_mode?: string;
-    vars?: {
-        [key: string]: any;
-    };
-    debug_id?: string;
-}

package/lib/posthog-node/src/extensions/express.d.ts

@@ -1,17 +0,0 @@
-/// <reference types="node" />
-import type * as http from 'node:http';
-import { PostHog } from '../posthog-node';
-type ExpressMiddleware = (req: http.IncomingMessage, res: http.ServerResponse, next: () => void) => void;
-type ExpressErrorMiddleware = (error: MiddlewareError, req: http.IncomingMessage, res: http.ServerResponse, next: (error: MiddlewareError) => void) => void;
-interface MiddlewareError extends Error {
-    status?: number | string;
-    statusCode?: number | string;
-    status_code?: number | string;
-    output?: {
-        statusCode?: number | string;
-    };
-}
-export declare function setupExpressErrorHandler(_posthog: PostHog, app: {
-    use: (middleware: ExpressMiddleware | ExpressErrorMiddleware) => unknown;
-}): void;
-export {};

package/lib/posthog-node/src/extensions/sentry-integration.d.ts

@@ -1,51 +0,0 @@
-/**
- * @file Adapted from [posthog-js](https://github.com/PostHog/posthog-js/blob/8157df935a4d0e71d2fefef7127aa85ee51c82d1/src/extensions/sentry-integration.ts) with modifications for the Node SDK.
- */
-/**
- * Integrate Sentry with PostHog. This will add a direct link to the person in Sentry, and an $exception event in PostHog.
- *
- * ### Usage
- *
- *     Sentry.init({
- *          dsn: 'https://example',
- *          integrations: [
- *              new PostHogSentryIntegration(posthog)
- *          ]
- *     })
- *
- *     Sentry.setTag(PostHogSentryIntegration.POSTHOG_ID_TAG, 'some distinct id');
- *
- * @param {Object} [posthog] The posthog object
- * @param {string} [organization] Optional: The Sentry organization, used to send a direct link from PostHog to Sentry
- * @param {Number} [projectId] Optional: The Sentry project id, used to send a direct link from PostHog to Sentry
- * @param {string} [prefix] Optional: Url of a self-hosted sentry instance (default: https://sentry.io/organizations/)
- * @param {SeverityLevel[] | '*'} [severityAllowList] Optional: send events matching the provided levels. Use '*' to send all events (default: ['error'])
- */
-import { SeverityLevel } from 'posthog-node/src/extensions/error-tracking/types';
-import { type PostHog } from '../posthog-node';
-type _SentryEvent = any;
-type _SentryEventProcessor = any;
-type _SentryHub = any;
-interface _SentryIntegration {
-    name: string;
-    processEvent(event: _SentryEvent): _SentryEvent;
-}
-interface _SentryIntegrationClass {
-    name: string;
-    setupOnce(addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub): void;
-}
-export type SentryIntegrationOptions = {
-    organization?: string;
-    projectId?: number;
-    prefix?: string;
-    severityAllowList?: SeverityLevel[] | '*';
-};
-export declare function createEventProcessor(_posthog: PostHog, { organization, projectId, prefix, severityAllowList }?: SentryIntegrationOptions): (event: _SentryEvent) => _SentryEvent;
-export declare function sentryIntegration(_posthog: PostHog, options?: SentryIntegrationOptions): _SentryIntegration;
-export declare class PostHogSentryIntegration implements _SentryIntegrationClass {
-    readonly name = "posthog-node";
-    static readonly POSTHOG_ID_TAG = "posthog_distinct_id";
-    setupOnce: (addGlobalEventProcessor: (callback: _SentryEventProcessor) => void, getCurrentHub: () => _SentryHub) => void;
-    constructor(_posthog: PostHog, organization?: string, prefix?: string, severityAllowList?: SeverityLevel[] | '*');
-}
-export {};

package/lib/posthog-node/src/feature-flags.d.ts

@@ -1,84 +0,0 @@
-/// <reference types="node" />
-import { FeatureFlagCondition, PostHogFeatureFlag, PropertyGroup } from './types';
-import { FeatureFlagValue, JsonType, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src';
-declare class ClientError extends Error {
-    constructor(message: string);
-}
-declare class InconclusiveMatchError extends Error {
-    constructor(message: string);
-}
-type FeatureFlagsPollerOptions = {
-    personalApiKey: string;
-    projectApiKey: string;
-    host: string;
-    pollingInterval: number;
-    timeout?: number;
-    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
-    onError?: (error: Error) => void;
-    onLoad?: (count: number) => void;
-    customHeaders?: {
-        [key: string]: string;
-    };
-};
-declare class FeatureFlagsPoller {
-    pollingInterval: number;
-    personalApiKey: string;
-    projectApiKey: string;
-    featureFlags: Array<PostHogFeatureFlag>;
-    featureFlagsByKey: Record<string, PostHogFeatureFlag>;
-    groupTypeMapping: Record<string, string>;
-    cohorts: Record<string, PropertyGroup>;
-    loadedSuccessfullyOnce: boolean;
-    timeout?: number;
-    host: FeatureFlagsPollerOptions['host'];
-    poller?: NodeJS.Timeout;
-    fetch: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
-    debugMode: boolean;
-    onError?: (error: Error) => void;
-    customHeaders?: {
-        [key: string]: string;
-    };
-    shouldBeginExponentialBackoff: boolean;
-    backOffCount: number;
-    onLoad?: (count: number) => void;
-    constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }: FeatureFlagsPollerOptions);
-    debug(enabled?: boolean): void;
-    private logMsgIfDebug;
-    getFeatureFlag(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<FeatureFlagValue | undefined>;
-    computeFeatureFlagPayloadLocally(key: string, matchValue: FeatureFlagValue): Promise<JsonType | undefined>;
-    getAllFlagsAndPayloads(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<{
-        response: Record<string, FeatureFlagValue>;
-        payloads: Record<string, JsonType>;
-        fallbackToDecide: boolean;
-    }>;
-    computeFlagLocally(flag: PostHogFeatureFlag, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>): Promise<FeatureFlagValue>;
-    matchFeatureFlagProperties(flag: PostHogFeatureFlag, distinctId: string, properties: Record<string, string>): Promise<FeatureFlagValue>;
-    isConditionMatch(flag: PostHogFeatureFlag, distinctId: string, condition: FeatureFlagCondition, properties: Record<string, string>): Promise<boolean>;
-    getMatchingVariant(flag: PostHogFeatureFlag, distinctId: string): Promise<FeatureFlagValue | undefined>;
-    variantLookupTable(flag: PostHogFeatureFlag): {
-        valueMin: number;
-        valueMax: number;
-        key: string;
-    }[];
-    loadFeatureFlags(forceReload?: boolean): Promise<void>;
-    /**
-     * Returns true if the feature flags poller has loaded successfully at least once and has more than 0 feature flags.
-     * This is useful to check if local evaluation is ready before calling getFeatureFlag.
-     */
-    isLocalEvaluationReady(): boolean;
-    /**
-     * If a client is misconfigured with an invalid or improper API key, the polling interval is doubled each time
-     * until a successful request is made, up to a maximum of 60 seconds.
-     *
-     * @returns The polling interval to use for the next request.
-     */
-    private getPollingInterval;
-    _loadFeatureFlags(): Promise<void>;
-    private getPersonalApiKeyRequestOptions;
-    _requestFeatureFlagDefinitions(): Promise<PostHogFetchResponse>;
-    stopPoller(): void;
-    _requestRemoteConfigPayload(flagKey: string): Promise<PostHogFetchResponse>;
-}
-declare function matchProperty(property: FeatureFlagCondition['properties'][number], propertyValues: Record<string, any>, warnFunction?: (msg: string) => void): boolean;
-declare function relativeDateParseForFeatureFlagMatching(value: string): Date | null;
-export { FeatureFlagsPoller, matchProperty, relativeDateParseForFeatureFlagMatching, InconclusiveMatchError, ClientError, };

package/lib/posthog-node/src/lazy.d.ts

@@ -1,23 +0,0 @@
-/**
- * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
- */
-export declare class Lazy<T> {
-    private value;
-    private factory;
-    private initializationPromise;
-    constructor(factory: () => Promise<T>);
-    /**
-     * Gets the value, initializing it if necessary.
-     * Multiple concurrent calls will share the same initialization promise.
-     */
-    getValue(): Promise<T>;
-    /**
-     * Returns true if the value has been initialized.
-     */
-    isInitialized(): boolean;
-    /**
-     * Returns a promise that resolves when the value is initialized.
-     * If already initialized, resolves immediately.
-     */
-    waitForInitialization(): Promise<void>;
-}

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

@@ -1,91 +0,0 @@
-import { JsonType, PostHogCoreOptions, PostHogCoreStateless, PostHogFetchOptions, PostHogFetchResponse, PostHogFlagsAndPayloadsResponse, PostHogPersistedProperty } from '../../posthog-core/src';
-import { EventMessage, GroupIdentifyMessage, IdentifyMessage, PostHogNodeV1 } from './types';
-import { FeatureFlagValue } from '../../posthog-core/src/types';
-import ErrorTracking from './error-tracking';
-export type PostHogOptions = PostHogCoreOptions & {
-    persistence?: 'memory';
-    personalApiKey?: string;
-    privacyMode?: boolean;
-    enableExceptionAutocapture?: boolean;
-    featureFlagsPollingInterval?: number;
-    maxCacheSize?: number;
-    fetch?: (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
-};
-export declare const MINIMUM_POLLING_INTERVAL = 100;
-export declare const THIRTY_SECONDS: number;
-export declare const SIXTY_SECONDS: number;
-export declare class PostHog extends PostHogCoreStateless implements PostHogNodeV1 {
-    private _memoryStorage;
-    private featureFlagsPoller?;
-    protected errorTracking: ErrorTracking;
-    private maxCacheSize;
-    readonly options: PostHogOptions;
-    distinctIdHasSentFlagCalls: Record<string, string[]>;
-    constructor(apiKey: string, options?: PostHogOptions);
-    getPersistedProperty(key: PostHogPersistedProperty): any | undefined;
-    setPersistedProperty(key: PostHogPersistedProperty, value: any | null): void;
-    fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
-    getLibraryId(): string;
-    getLibraryVersion(): string;
-    getCustomUserAgent(): string;
-    enable(): Promise<void>;
-    disable(): Promise<void>;
-    debug(enabled?: boolean): void;
-    capture(props: EventMessage): void;
-    identify({ distinctId, properties, disableGeoip }: IdentifyMessage): void;
-    alias(data: {
-        distinctId: string;
-        alias: string;
-        disableGeoip?: boolean;
-    }): void;
-    isLocalEvaluationReady(): boolean;
-    waitForLocalEvaluationReady(timeoutMs?: number): Promise<boolean>;
-    getFeatureFlag(key: string, distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        sendFeatureFlagEvents?: boolean;
-        disableGeoip?: boolean;
-    }): Promise<FeatureFlagValue | undefined>;
-    getFeatureFlagPayload(key: string, distinctId: string, matchValue?: FeatureFlagValue, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        sendFeatureFlagEvents?: boolean;
-        disableGeoip?: boolean;
-    }): Promise<JsonType | undefined>;
-    getRemoteConfigPayload(flagKey: string): Promise<JsonType | undefined>;
-    isFeatureEnabled(key: string, distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        sendFeatureFlagEvents?: boolean;
-        disableGeoip?: boolean;
-    }): Promise<boolean | undefined>;
-    getAllFlags(distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        disableGeoip?: boolean;
-    }): Promise<Record<string, FeatureFlagValue>>;
-    getAllFlagsAndPayloads(distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        disableGeoip?: boolean;
-    }): Promise<PostHogFlagsAndPayloadsResponse>;
-    groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }: GroupIdentifyMessage): void;
-    /**
-     * Reloads the feature flag definitions from the server for local evaluation.
-     * This is useful to call if you want to ensure that the feature flags are up to date before calling getFeatureFlag.
-     */
-    reloadFeatureFlags(): Promise<void>;
-    shutdown(shutdownTimeoutMs?: number): Promise<void>;
-    private addLocalPersonAndGroupProperties;
-    captureException(error: unknown, distinctId?: string, additionalProperties?: Record<string | number, any>): void;
-}

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

@@ -1,203 +0,0 @@
-import { FeatureFlagValue, JsonType } from '../../posthog-core/src';
-export interface IdentifyMessage {
-    distinctId: string;
-    properties?: Record<string | number, any>;
-    disableGeoip?: boolean;
-}
-export interface EventMessage extends IdentifyMessage {
-    event: string;
-    groups?: Record<string, string | number>;
-    sendFeatureFlags?: boolean;
-    timestamp?: Date;
-    uuid?: string;
-}
-export interface GroupIdentifyMessage {
-    groupType: string;
-    groupKey: string;
-    properties?: Record<string | number, any>;
-    distinctId?: string;
-    disableGeoip?: boolean;
-}
-export type PropertyGroup = {
-    type: 'AND' | 'OR';
-    values: PropertyGroup[] | FlagProperty[];
-};
-export type FlagProperty = {
-    key: string;
-    type?: string;
-    value: string | number | (string | number)[];
-    operator?: string;
-    negation?: boolean;
-};
-export type FeatureFlagCondition = {
-    properties: FlagProperty[];
-    rollout_percentage?: number;
-    variant?: string;
-};
-export type PostHogFeatureFlag = {
-    id: number;
-    name: string;
-    key: string;
-    filters?: {
-        aggregation_group_type_index?: number;
-        groups?: FeatureFlagCondition[];
-        multivariate?: {
-            variants: {
-                key: string;
-                rollout_percentage: number;
-            }[];
-        };
-        payloads?: Record<string, string>;
-    };
-    deleted: boolean;
-    active: boolean;
-    /** @deprecated This field will be removed in a future version. **/
-    is_simple_flag: boolean;
-    rollout_percentage: null | number;
-    ensure_experience_continuity: boolean;
-    experiment_set: number[];
-};
-export type PostHogNodeV1 = {
-    /**
-     * @description Capture allows you to capture anything a user does within your system,
-     * which you can later use in PostHog to find patterns in usage,
-     * work out which features to improve or where people are giving up.
-     * A capture call requires:
-     * @param distinctId which uniquely identifies your user
-     * @param event We recommend using [verb] [noun], like movie played or movie updated to easily identify what your events mean later on.
-     * @param properties OPTIONAL | which can be a object with any information you'd like to add
-     * @param groups OPTIONAL | object of what groups are related to this event, example: { company: 'id:5' }. Can be used to analyze companies instead of users.
-     * @param sendFeatureFlags OPTIONAL | Used with experiments. Determines whether to send feature flag values with the event.
-     */
-    capture({ distinctId, event, properties, groups, sendFeatureFlags }: EventMessage): void;
-    /**
-     * @description Identify lets you add metadata on your users so you can more easily identify who they are in PostHog,
-     * and even do things like segment users by these properties.
-     * An identify call requires:
-     * @param distinctId which uniquely identifies your user
-     * @param properties with a dict with any key: value pairs
-     */
-    identify({ distinctId, properties }: IdentifyMessage): void;
-    /**
-     * @description To marry up whatever a user does before they sign up or log in with what they do after you need to make an alias call.
-     * This will allow you to answer questions like "Which marketing channels leads to users churning after a month?"
-     * or "What do users do on our website before signing up?"
-     * In a purely back-end implementation, this means whenever an anonymous user does something, you'll want to send a session ID with the capture call.
-     * Then, when that users signs up, you want to do an alias call with the session ID and the newly created user ID.
-     * The same concept applies for when a user logs in. If you're using PostHog in the front-end and back-end,
-     *  doing the identify call in the frontend will be enough.:
-     * @param distinctId the current unique id
-     * @param alias the unique ID of the user before
-     */
-    alias(data: {
-        distinctId: string;
-        alias: string;
-    }): void;
-    /**
-     * @description PostHog feature flags (https://posthog.com/docs/features/feature-flags)
-     * allow you to safely deploy and roll back new features. Once you've created a feature flag in PostHog,
-     * you can use this method to check if the flag is on for a given user, allowing you to create logic to turn
-     * features on and off for different user groups or individual users.
-     * @param key the unique key of your feature flag
-     * @param distinctId the current unique id
-     * @param options: dict with optional parameters below
-     * @param groups optional - what groups are currently active (group analytics). Required if the flag depends on groups.
-     * @param personProperties optional - what person properties are known. Used to compute flags locally, if personalApiKey is present.
-     * @param groupProperties optional - what group properties are known. Used to compute flags locally, if personalApiKey is present.
-     * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
-     * @param sendFeatureFlagEvents optional - whether to send feature flag events. Used for Experiments. Defaults to true.
-     *
-     * @returns true if the flag is on, false if the flag is off, undefined if there was an error.
-     */
-    isFeatureEnabled(key: string, distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        sendFeatureFlagEvents?: boolean;
-    }): Promise<boolean | undefined>;
-    /**
-     * @description PostHog feature flags (https://posthog.com/docs/features/feature-flags)
-     * allow you to safely deploy and roll back new features. Once you've created a feature flag in PostHog,
-     * you can use this method to check if the flag is on for a given user, allowing you to create logic to turn
-     * features on and off for different user groups or individual users.
-     * @param key the unique key of your feature flag
-     * @param distinctId the current unique id
-     * @param options: dict with optional parameters below
-     * @param groups optional - what groups are currently active (group analytics). Required if the flag depends on groups.
-     * @param personProperties optional - what person properties are known. Used to compute flags locally, if personalApiKey is present.
-     * @param groupProperties optional - what group properties are known. Used to compute flags locally, if personalApiKey is present.
-     * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
-     * @param sendFeatureFlagEvents optional - whether to send feature flag events. Used for Experiments. Defaults to true.
-     *
-     * @returns true or string(for multivariates) if the flag is on, false if the flag is off, undefined if there was an error.
-     */
-    getFeatureFlag(key: string, distinctId: string, options?: {
-        groups?: Record<string, string>;
-        personProperties?: Record<string, string>;
-        groupProperties?: Record<string, Record<string, string>>;
-        onlyEvaluateLocally?: boolean;
-        sendFeatureFlagEvents?: boolean;
-    }): Promise<FeatureFlagValue | undefined>;
-    /**
-     * @description Retrieves payload associated with the specified flag and matched value that is passed in.
-     *
-     * IMPORTANT: The `matchValue` parameter should be the value you previously obtained from `getFeatureFlag()`.
-     * If matchValue isn't passed (or is undefined), this method will automatically call `getFeatureFlag()`
-     * internally to fetch the flag value, which could result in a network call to the PostHog server if this flag can
-     * not be evaluated locally. This means that omitting `matchValue` will potentially:
-     * - Bypass local evaluation
-     * - Count as an additional flag evaluation against your quota
-     * - Impact performance due to the extra network request
-     *
-     * Example usage:
-     * ```js
-     * const flagValue = await client.getFeatureFlag('my-flag', distinctId);
-     * const payload = await client.getFeatureFlagPayload('my-flag', distinctId, flagValue);
-     * ```
-     *
-     * @param key the unique key of your feature flag
-     * @param distinctId the current unique id
-     * @param matchValue The flag value previously obtained from calling `getFeatureFlag()`. Can be a string or boolean.
-     *                   To avoid extra network calls, pass this parameter when you can.
-     * @param options: dict with optional parameters below
-     * @param onlyEvaluateLocally optional - whether to only evaluate the flag locally. Defaults to false.
-     *
-     * @returns payload of a json type object
-     */
-    getFeatureFlagPayload(key: string, distinctId: string, matchValue?: FeatureFlagValue, options?: {
-        onlyEvaluateLocally?: boolean;
-    }): Promise<JsonType | undefined>;
-    /**
-     * @description Sets a groups properties, which allows asking questions like "Who are the most active companies"
-     * using my product in PostHog.
-     *
-     * @param groupType Type of group (ex: 'company'). Limited to 5 per project
-     * @param groupKey Unique identifier for that type of group (ex: 'id:5')
-     * @param properties OPTIONAL | which can be a object with any information you'd like to add
-     */
-    groupIdentify({ groupType, groupKey, properties }: GroupIdentifyMessage): void;
-    /**
-     * @description Force an immediate reload of the polled feature flags. Please note that they are
-     * already polled automatically at a regular interval.
-     */
-    reloadFeatureFlags(): Promise<void>;
-    /**
-     * @description Flushes the events still in the queue and clears the feature flags poller to allow for
-     * a clean shutdown.
-     *
-     * @param shutdownTimeoutMs The shutdown timeout, in milliseconds. Defaults to 30000 (30s).
-     */
-    shutdown(shutdownTimeoutMs?: number): void;
-    /**
-     * @description Waits for local evaluation to be ready, with an optional timeout.
-     * @param timeoutMs - Maximum time to wait in milliseconds. Defaults to 30 seconds.
-     * @returns A promise that resolves to true if local evaluation is ready, false if the timeout was reached.
-     */
-    waitForLocalEvaluationReady(timeoutMs?: number): Promise<boolean>;
-    /**
-     * @description Returns true if local evaluation is ready, false if it's not.
-     * @returns true if local evaluation is ready, false if it's not.
-     */
-    isLocalEvaluationReady(): boolean;
-};

package/lib/posthog-node/test/test-utils.d.ts

@@ -1,17 +0,0 @@
-import { PostHogV4DecideResponse } from 'posthog-core/src/types';
-type ErrorResponse = {
-    status: number;
-    json: () => Promise<any>;
-};
-export declare const apiImplementationV4: (decideResponse: PostHogV4DecideResponse | ErrorResponse) => (url: any) => Promise<any>;
-export declare const apiImplementation: ({ localFlags, decideFlags, decideFlagPayloads, decideStatus, localFlagsStatus, errorsWhileComputingFlags, }: {
-    localFlags?: any;
-    decideFlags?: any;
-    decideFlagPayloads?: any;
-    decideStatus?: number | undefined;
-    localFlagsStatus?: number | undefined;
-    errorsWhileComputingFlags?: boolean | undefined;
-}) => (url: any) => Promise<any>;
-export declare const anyLocalEvalCall: any[];
-export declare const anyDecideCall: any[];
-export {};

package/src/crypto-helpers.ts

@@ -1,36 +0,0 @@
-/// <reference lib="dom" />
-import { Lazy } from 'posthog-node/src/lazy'
-
-const nodeCrypto = new Lazy(async () => {
-  try {
-    return await import('crypto')
-  } catch {
-    return undefined
-  }
-})
-
-export async function getNodeCrypto(): Promise<typeof import('crypto') | undefined> {
-  return await nodeCrypto.getValue()
-}
-
-const webCrypto = new Lazy(async (): Promise<SubtleCrypto | undefined> => {
-  if (typeof globalThis.crypto?.subtle !== 'undefined') {
-    return globalThis.crypto.subtle
-  }
-
-  try {
-    // Node.js: use built-in webcrypto and assign it if needed
-    const crypto = await nodeCrypto.getValue()
-    if (crypto?.webcrypto?.subtle) {
-      return crypto.webcrypto.subtle as SubtleCrypto
-    }
-  } catch {
-    // Ignore if not available
-  }
-
-  return undefined
-})
-
-export async function getWebCrypto(): Promise<SubtleCrypto | undefined> {
-  return await webCrypto.getValue()
-}

package/src/crypto.ts

@@ -1,22 +0,0 @@
-/// <reference lib="dom" />
-
-import { getNodeCrypto, getWebCrypto } from './crypto-helpers'
-
-export async function hashSHA1(text: string): Promise<string> {
-  // Try Node.js crypto first
-  const nodeCrypto = await getNodeCrypto()
-  if (nodeCrypto) {
-    return nodeCrypto.createHash('sha1').update(text).digest('hex')
-  }
-
-  const webCrypto = await getWebCrypto()
-
-  // Fall back to Web Crypto API
-  if (webCrypto) {
-    const hashBuffer = await webCrypto.digest('SHA-1', new TextEncoder().encode(text))
-    const hashArray = Array.from(new Uint8Array(hashBuffer))
-    return hashArray.map((byte) => byte.toString(16).padStart(2, '0')).join('')
-  }
-
-  throw new Error('No crypto implementation available. Tried Node Crypto API and Web SubtleCrypto API')
-}