posthog-node 4.16.0 → 4.17.1

package/src/fetch.ts

@@ -1,39 +0,0 @@
-/**
- * Fetch wrapper
- *
- * We want to polyfill fetch when not available with axios but use it when it is.
- * NOTE: The current version of Axios has an issue when in non-node environments like Clouflare Workers.
- * This is currently solved by using the global fetch if available instead.
- * See https://github.com/PostHog/posthog-js-lite/issues/127 for more info
- */
-
-import { FetchLike, PostHogFetchOptions, PostHogFetchResponse } from 'posthog-core/src'
-import { getFetch } from 'posthog-core/src/utils'
-
-let _fetch: FetchLike | undefined = getFetch()
-
-if (!_fetch) {
-  // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const axios = require('axios')
-
-  _fetch = async (url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse> => {
-    const res = await axios.request({
-      url,
-      headers: options.headers,
-      method: options.method.toLowerCase(),
-      data: options.body,
-      signal: options.signal,
-      // fetch only throws on network errors, not on HTTP errors
-      validateStatus: () => true,
-    })
-
-    return {
-      status: res.status,
-      text: async () => res.data,
-      json: async () => res.data,
-    }
-  }
-}
-
-// NOTE: We have to export this as default, even though we prefer named exports as we are relying on detecting "fetch" in the global scope
-export default _fetch as FetchLike

package/src/lazy.ts

@@ -1,55 +0,0 @@
-/**
- * A lazy value that is only computed when needed. Inspired by C#'s Lazy<T> class.
- */
-export class Lazy<T> {
-  private value: T | undefined
-  private factory: () => Promise<T>
-  private initializationPromise: Promise<T> | undefined
-
-  constructor(factory: () => Promise<T>) {
-    this.factory = factory
-  }
-
-  /**
-   * Gets the value, initializing it if necessary.
-   * Multiple concurrent calls will share the same initialization promise.
-   */
-  async getValue(): Promise<T> {
-    if (this.value !== undefined) {
-      return this.value
-    }
-
-    if (this.initializationPromise === undefined) {
-      this.initializationPromise = (async () => {
-        try {
-          const result = await this.factory()
-          this.value = result
-          return result
-        } finally {
-          // Clear the promise so we can retry if needed
-          this.initializationPromise = undefined
-        }
-      })()
-    }
-
-    return this.initializationPromise
-  }
-
-  /**
-   * Returns true if the value has been initialized.
-   */
-  isInitialized(): boolean {
-    return this.value !== undefined
-  }
-
-  /**
-   * Returns a promise that resolves when the value is initialized.
-   * If already initialized, resolves immediately.
-   */
-  async waitForInitialization(): Promise<void> {
-    if (this.isInitialized()) {
-      return
-    }
-    await this.getValue()
-  }
-}