@databuddy/sdk 2.1.78 → 2.2.1

package/dist/node/index.mjs

@@ -0,0 +1,512 @@
+function createLogger(debug = false) {
+  try {
+    const pino = require("pino");
+    return pino({
+      level: debug ? "debug" : "info",
+      name: "databuddy"
+    });
+  } catch {
+    return createConsoleLogger(debug);
+  }
+}
+function createConsoleLogger(debug) {
+  const noop = () => {
+  };
+  return {
+    info(msg, data) {
+      if (debug) {
+        console.info(`[Databuddy] ${msg}`, data ? JSON.stringify(data) : "");
+      }
+    },
+    error(msg, data) {
+      if (debug) {
+        console.error(
+          `[Databuddy] ${msg}`,
+          data ? JSON.stringify(data) : ""
+        );
+      }
+    },
+    warn(msg, data) {
+      if (debug) {
+        console.warn(`[Databuddy] ${msg}`, data ? JSON.stringify(data) : "");
+      }
+    },
+    debug: debug ? (msg, data) => {
+      console.debug(
+        `[Databuddy] ${msg}`,
+        data ? JSON.stringify(data) : ""
+      );
+    } : noop
+  };
+}
+function createNoopLogger() {
+  const noop = () => {
+  };
+  return {
+    info: noop,
+    error: noop,
+    warn: noop,
+    debug: noop
+  };
+}
+
+class EventQueue {
+  queue = [];
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  add(event) {
+    this.queue.push(event);
+    return this.queue.length >= this.maxSize;
+  }
+  getAll() {
+    return [...this.queue];
+  }
+  clear() {
+    this.queue = [];
+  }
+  size() {
+    return this.queue.length;
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+}
+
+const DEFAULT_API_URL = "https://basket.databuddy.cc";
+const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_TIMEOUT = 2e3;
+const DEFAULT_MAX_QUEUE_SIZE = 1e3;
+const DEFAULT_MAX_DEDUPLICATION_CACHE_SIZE = 1e4;
+class Databuddy {
+  clientId;
+  apiUrl;
+  logger;
+  enableBatching;
+  batchSize;
+  batchTimeout;
+  queue;
+  flushTimer = null;
+  globalProperties = {};
+  middleware = [];
+  enableDeduplication;
+  deduplicationCache = /* @__PURE__ */ new Set();
+  maxDeduplicationCacheSize;
+  constructor(config) {
+    if (!config.clientId || typeof config.clientId !== "string") {
+      throw new Error("clientId is required and must be a string");
+    }
+    this.clientId = config.clientId.trim();
+    this.apiUrl = config.apiUrl?.trim() || DEFAULT_API_URL;
+    this.enableBatching = config.enableBatching !== false;
+    this.batchSize = Math.min(config.batchSize || DEFAULT_BATCH_SIZE, 100);
+    this.batchTimeout = config.batchTimeout || DEFAULT_BATCH_TIMEOUT;
+    this.queue = new EventQueue(config.maxQueueSize || DEFAULT_MAX_QUEUE_SIZE);
+    this.middleware = config.middleware || [];
+    this.enableDeduplication = config.enableDeduplication !== false;
+    this.maxDeduplicationCacheSize = config.maxDeduplicationCacheSize || DEFAULT_MAX_DEDUPLICATION_CACHE_SIZE;
+    if (config.logger) {
+      this.logger = config.logger;
+    } else if (config.debug) {
+      this.logger = createLogger(true);
+    } else {
+      this.logger = createNoopLogger();
+    }
+    this.logger.info("Initialized", {
+      clientId: this.clientId,
+      apiUrl: this.apiUrl,
+      enableBatching: this.enableBatching,
+      batchSize: this.batchSize,
+      batchTimeout: this.batchTimeout,
+      middlewareCount: this.middleware.length,
+      enableDeduplication: this.enableDeduplication
+    });
+  }
+  /**
+   * Track a custom event
+   * @param event - Event data to track
+   * @returns Promise with success/error response
+   * @example
+   * ```typescript
+   * await client.track({
+   *   name: 'user_signup',
+   *   properties: { plan: 'pro', source: 'web' }
+   * });
+   * ```
+   */
+  async track(event) {
+    if (!event.name || typeof event.name !== "string") {
+      return {
+        success: false,
+        error: "Event name is required and must be a string"
+      };
+    }
+    const batchEvent = {
+      type: "custom",
+      name: event.name,
+      eventId: event.eventId,
+      anonymousId: event.anonymousId,
+      sessionId: event.sessionId,
+      timestamp: event.timestamp,
+      properties: {
+        ...this.globalProperties,
+        ...event.properties || {}
+      }
+    };
+    const processedEvent = await this.applyMiddleware(batchEvent);
+    if (!processedEvent) {
+      this.logger.debug("Event dropped by middleware", { name: event.name });
+      return { success: true };
+    }
+    if (this.enableDeduplication && processedEvent.eventId) {
+      if (this.deduplicationCache.has(processedEvent.eventId)) {
+        this.logger.debug("Event deduplicated", { eventId: processedEvent.eventId });
+        return { success: true };
+      }
+      this.addToDeduplicationCache(processedEvent.eventId);
+    }
+    if (!this.enableBatching) {
+      return this.send(processedEvent);
+    }
+    const shouldFlush = this.queue.add(processedEvent);
+    this.logger.debug("Event queued", { queueSize: this.queue.size() });
+    this.scheduleFlush();
+    if (shouldFlush || this.queue.size() >= this.batchSize) {
+      await this.flush();
+    }
+    return { success: true };
+  }
+  async send(event) {
+    try {
+      const url = `${this.apiUrl}/?client_id=${encodeURIComponent(this.clientId)}`;
+      this.logger.info("\u{1F4E4} SENDING SINGLE EVENT:", {
+        name: event.name,
+        properties: JSON.stringify(event.properties, null, 2),
+        propertiesCount: Object.keys(event.properties || {}).length
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        this.logger.error("Request failed", {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorText
+        });
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      this.logger.info("Response received", data);
+      if (data.status === "success") {
+        return {
+          success: true,
+          eventId: data.eventId
+        };
+      }
+      return {
+        success: false,
+        error: data.message || "Unknown error from server"
+      };
+    } catch (error) {
+      this.logger.error("Request error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network request failed"
+      };
+    }
+  }
+  scheduleFlush() {
+    if (this.flushTimer) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flush().catch((error) => {
+        this.logger.error("Auto-flush error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }, this.batchTimeout);
+  }
+  /**
+   * Manually flush all queued events
+   * Useful in serverless environments to ensure events are sent before process exits
+   * @returns Promise with batch results
+   * @example
+   * ```typescript
+   * await client.track({ name: 'api_call' });
+   * await client.flush(); // Ensure events are sent
+   * ```
+   */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.queue.isEmpty()) {
+      return {
+        success: true,
+        processed: 0,
+        results: []
+      };
+    }
+    const events = this.queue.getAll();
+    this.queue.clear();
+    this.logger.info("Flushing events", { count: events.length });
+    return this.batch(events);
+  }
+  /**
+   * Send multiple events in a single batch request
+   * @param events - Array of events to batch (max 100)
+   * @returns Promise with batch results
+   * @example
+   * ```typescript
+   * await client.batch([
+   *   { type: 'custom', name: 'event1', properties: { foo: 'bar' } },
+   *   { type: 'custom', name: 'event2', properties: { baz: 'qux' } }
+   * ]);
+   * ```
+   */
+  async batch(events) {
+    if (!Array.isArray(events)) {
+      return {
+        success: false,
+        error: "Events must be an array"
+      };
+    }
+    if (events.length === 0) {
+      return {
+        success: false,
+        error: "Events array cannot be empty"
+      };
+    }
+    if (events.length > 100) {
+      return {
+        success: false,
+        error: "Batch size cannot exceed 100 events"
+      };
+    }
+    for (const event of events) {
+      if (!event.name || typeof event.name !== "string") {
+        return {
+          success: false,
+          error: "All events must have a valid name"
+        };
+      }
+    }
+    const enrichedEvents = events.map((event) => ({
+      ...event,
+      properties: {
+        ...this.globalProperties,
+        ...event.properties || {}
+      }
+    }));
+    const processedEvents = [];
+    for (const event of enrichedEvents) {
+      const processedEvent = await this.applyMiddleware(event);
+      if (!processedEvent) {
+        continue;
+      }
+      if (this.enableDeduplication && processedEvent.eventId) {
+        if (this.deduplicationCache.has(processedEvent.eventId)) {
+          this.logger.debug("Event deduplicated in batch", { eventId: processedEvent.eventId });
+          continue;
+        }
+        this.addToDeduplicationCache(processedEvent.eventId);
+      }
+      processedEvents.push(processedEvent);
+    }
+    if (processedEvents.length === 0) {
+      return {
+        success: true,
+        processed: 0,
+        results: []
+      };
+    }
+    try {
+      const url = `${this.apiUrl}/batch?client_id=${encodeURIComponent(this.clientId)}`;
+      this.logger.info("\u{1F4E6} SENDING BATCH EVENTS:", {
+        count: processedEvents.length,
+        firstEventName: processedEvents[0]?.name,
+        firstEventProperties: JSON.stringify(processedEvents[0]?.properties, null, 2),
+        firstEventPropertiesCount: Object.keys(processedEvents[0]?.properties || {}).length
+      });
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(processedEvents)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "Unknown error");
+        this.logger.error("Batch request failed", {
+          status: response.status,
+          statusText: response.statusText,
+          body: errorText
+        });
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`
+        };
+      }
+      const data = await response.json();
+      this.logger.info("Batch response received", data);
+      if (data.status === "success") {
+        return {
+          success: true,
+          processed: data.processed || processedEvents.length,
+          results: data.results
+        };
+      }
+      return {
+        success: false,
+        error: data.message || "Unknown error from server"
+      };
+    } catch (error) {
+      this.logger.error("Batch request error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network request failed"
+      };
+    }
+  }
+  /**
+   * Set global properties attached to all events
+   * Properties are merged with existing globals; event properties override globals
+   * @param properties - Properties to merge with existing globals
+   * @example
+   * ```typescript
+   * client.setGlobalProperties({ environment: 'production', version: '1.0.0' });
+   * // All subsequent events will include these properties
+   * ```
+   */
+  setGlobalProperties(properties) {
+    this.globalProperties = { ...this.globalProperties, ...properties };
+    this.logger.debug("Global properties updated", { properties });
+  }
+  /**
+   * Get current global properties
+   * @returns Copy of current global properties
+   * @example
+   * ```typescript
+   * const globals = client.getGlobalProperties();
+   * console.log(globals); // { environment: 'production', version: '1.0.0' }
+   * ```
+   */
+  getGlobalProperties() {
+    return { ...this.globalProperties };
+  }
+  /**
+   * Clear all global properties
+   * @example
+   * ```typescript
+   * client.clearGlobalProperties();
+   * // No more global properties will be attached to events
+   * ```
+   */
+  clearGlobalProperties() {
+    this.globalProperties = {};
+    this.logger.debug("Global properties cleared");
+  }
+  /**
+   * Add middleware to transform events
+   * Middleware runs before deduplication and is executed in order
+   * Return null to drop the event, or return a modified event
+   * @param middleware - Middleware function
+   * @example
+   * ```typescript
+   * client.addMiddleware((event) => {
+   *   // Add custom field
+   *   event.properties = { ...event.properties, processed: true };
+   *   return event;
+   * });
+   * 
+   * // Drop events matching a condition
+   * client.addMiddleware((event) => {
+   *   if (event.name === 'unwanted_event') return null;
+   *   return event;
+   * });
+   * ```
+   */
+  addMiddleware(middleware) {
+    this.middleware.push(middleware);
+    this.logger.debug("Middleware added", { totalMiddleware: this.middleware.length });
+  }
+  /**
+   * Remove all middleware functions
+   * @example
+   * ```typescript
+   * client.clearMiddleware();
+   * // All middleware transformations removed
+   * ```
+   */
+  clearMiddleware() {
+    this.middleware = [];
+    this.logger.debug("Middleware cleared");
+  }
+  /**
+   * Get current deduplication cache size
+   * @returns Number of event IDs in cache
+   * @example
+   * ```typescript
+   * const size = client.getDeduplicationCacheSize();
+   * console.log(`Cache size: ${size}`);
+   * ```
+   */
+  getDeduplicationCacheSize() {
+    return this.deduplicationCache.size;
+  }
+  /**
+   * Clear the deduplication cache
+   * Useful for testing or resetting duplicate detection
+   * @example
+   * ```typescript
+   * client.clearDeduplicationCache();
+   * // All cached event IDs cleared
+   * ```
+   */
+  clearDeduplicationCache() {
+    this.deduplicationCache.clear();
+    this.logger.debug("Deduplication cache cleared");
+  }
+  async applyMiddleware(event) {
+    let processedEvent = event;
+    for (const middleware of this.middleware) {
+      if (!processedEvent) {
+        break;
+      }
+      try {
+        processedEvent = await middleware(processedEvent);
+      } catch (error) {
+        this.logger.error("Middleware error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return processedEvent;
+  }
+  addToDeduplicationCache(eventId) {
+    if (this.deduplicationCache.size >= this.maxDeduplicationCacheSize) {
+      const oldest = this.deduplicationCache.values().next().value;
+      if (oldest) {
+        this.deduplicationCache.delete(oldest);
+      }
+    }
+    this.deduplicationCache.add(eventId);
+  }
+}
+
+export { Databuddy, Databuddy as db };

package/dist/react/index.d.mts

@@ -1,12 +1,25 @@
-export { b as Databuddy } from '../shared/@databuddy/sdk.C8T93n5r.mjs';
+import { D as DatabuddyConfig } from '../shared/@databuddy/sdk.DNing6--.mjs';
+import * as react from 'react';
 import { ReactNode } from 'react';
+import * as jotai_vanilla_internals from 'jotai/vanilla/internals';
 import { d as FlagsConfig, c as FlagState } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 export { b as FlagResult, e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.mjs';
 
+/**
+ * <Databuddy /> component for Next.js/React apps
+ * Injects the databuddy.js script with all config as data attributes
+ * Usage: <Databuddy clientId="..." trackScreenViews trackPerformance ... />
+ * Or simply: <Databuddy /> (auto-detects clientId from environment variables)
+ */
+declare function Databuddy(props: DatabuddyConfig): null;
+
 interface FlagsProviderProps extends FlagsConfig {
     children: ReactNode;
 }
-declare function FlagsProvider({ children, ...config }: FlagsProviderProps): any;
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
+    children?: ReactNode;
+    store?: jotai_vanilla_internals.INTERNAL_Store;
+}>;
 declare function useFlags(): {
     isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void> | undefined;
@@ -14,4 +27,4 @@ declare function useFlags(): {
     refresh: (forceClear?: boolean) => void;
 };
 
-export { FlagState, FlagsConfig, FlagsProvider, useFlags };
+export { Databuddy, FlagState, FlagsConfig, FlagsProvider, useFlags };

package/dist/react/index.d.ts

@@ -1,12 +1,25 @@
-export { b as Databuddy } from '../shared/@databuddy/sdk.C8T93n5r.js';
+import { D as DatabuddyConfig } from '../shared/@databuddy/sdk.DNing6--.js';
+import * as react from 'react';
 import { ReactNode } from 'react';
+import * as jotai_vanilla_internals from 'jotai/vanilla/internals';
 import { d as FlagsConfig, c as FlagState } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 export { b as FlagResult, e as FlagsContext } from '../shared/@databuddy/sdk.YfiY9DoZ.js';
 
+/**
+ * <Databuddy /> component for Next.js/React apps
+ * Injects the databuddy.js script with all config as data attributes
+ * Usage: <Databuddy clientId="..." trackScreenViews trackPerformance ... />
+ * Or simply: <Databuddy /> (auto-detects clientId from environment variables)
+ */
+declare function Databuddy(props: DatabuddyConfig): null;
+
 interface FlagsProviderProps extends FlagsConfig {
     children: ReactNode;
 }
-declare function FlagsProvider({ children, ...config }: FlagsProviderProps): any;
+declare function FlagsProvider({ children, ...config }: FlagsProviderProps): react.FunctionComponentElement<{
+    children?: ReactNode;
+    store?: jotai_vanilla_internals.INTERNAL_Store;
+}>;
 declare function useFlags(): {
     isEnabled: (key: string) => FlagState;
     fetchAllFlags: () => Promise<void> | undefined;
@@ -14,4 +27,4 @@ declare function useFlags(): {
     refresh: (forceClear?: boolean) => void;
 };
 
-export { FlagState, FlagsConfig, FlagsProvider, useFlags };
+export { Databuddy, FlagState, FlagsConfig, FlagsProvider, useFlags };

package/dist/react/index.mjs

@@ -1,9 +1,26 @@
 'use client';
 
-export { D as Databuddy } from '../shared/@databuddy/sdk.CHuEu0ou.mjs';
+import { i as isScriptInjected, c as createScript, B as BrowserFlagStorage, C as CoreFlagsManager, l as logger } from '../shared/@databuddy/sdk.tFAHtL2M.mjs';
+import { d as detectClientId } from '../shared/@databuddy/sdk.BUsPV0LH.mjs';
 import { createStore, atom, Provider, useAtom } from 'jotai';
 import { useRef, useEffect, createElement } from 'react';
-import { B as BrowserFlagStorage, C as CoreFlagsManager, l as logger } from '../shared/@databuddy/sdk.ItWNeH-Y.mjs';
+
+function Databuddy(props) {
+  const clientId = detectClientId(props.clientId);
+  if (!clientId) {
+    if (typeof window !== "undefined" && !props.disabled && props.debug) {
+      console.warn(
+        "Databuddy: No client ID found. Please provide clientId prop or set NEXT_PUBLIC_DATABUDDY_CLIENT_ID environment variable."
+      );
+    }
+    return null;
+  }
+  if (typeof window !== "undefined" && !props.disabled && !isScriptInjected()) {
+    const script = createScript({ ...props, clientId });
+    document.head.appendChild(script);
+  }
+  return null;
+}
 
 const flagsStore = createStore();
 const managerAtom = atom(null);
@@ -102,4 +119,4 @@ function useFlags() {
   };
 }
 
-export { FlagsProvider, useFlags };
+export { Databuddy, FlagsProvider, useFlags };

package/dist/shared/@databuddy/{sdk.CHuEu0ou.mjs → sdk.BUsPV0LH.mjs}

@@ -1,5 +1,3 @@
-import { i as isScriptInjected, c as createScript } from './sdk.ItWNeH-Y.mjs';
-
 function detectClientId(providedClientId) {
   if (providedClientId) {
     return providedClientId;
@@ -24,21 +22,4 @@ function detectClientId(providedClientId) {
   return;
 }
 
-function Databuddy(props) {
-  const clientId = detectClientId(props.clientId);
-  if (!clientId) {
-    if (typeof window !== "undefined" && !props.disabled && props.debug) {
-      console.warn(
-        "Databuddy: No client ID found. Please provide clientId prop or set NEXT_PUBLIC_DATABUDDY_CLIENT_ID environment variable."
-      );
-    }
-    return null;
-  }
-  if (typeof window !== "undefined" && !props.disabled && !isScriptInjected()) {
-    const script = createScript({ ...props, clientId });
-    document.head.appendChild(script);
-  }
-  return null;
-}
-
-export { Databuddy as D, detectClientId as d };
+export { detectClientId as d };

package/dist/shared/@databuddy/{sdk.C8T93n5r.d.mts → sdk.DNing6--.d.mts}

@@ -276,6 +276,14 @@ type PropertiesForEvent<T extends EventName> = T extends keyof EventTypeMap ? Ev
  * Databuddy tracker instance interface
  */
 interface DatabuddyTracker {
+    /**
+     * Current anonymous user ID
+     */
+    anonymousId: string;
+    /**
+     * Current session ID
+     */
+    sessionId: string;
     /**
      * Track a custom event
      */
@@ -333,13 +341,4 @@ type TrackFunction = <T extends EventName>(eventName: T, properties?: Properties
 type ScreenViewFunction = (path?: string, properties?: EventProperties) => void;
 type SetGlobalPropertiesFunction = (properties: EventProperties) => void;
 
-/**
- * <Databuddy /> component for Next.js/React apps
- * Injects the databuddy.js script with all config as data attributes
- * Usage: <Databuddy clientId="..." trackScreenViews trackPerformance ... />
- * Or simply: <Databuddy /> (auto-detects clientId from environment variables)
- */
-declare function Databuddy(props: DatabuddyConfig): null;
-
-export { Databuddy as b };
-export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as c, EventName as d, DataAttributes as e, SetGlobalPropertiesFunction as f };
+export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as b, EventName as c, DataAttributes as d, SetGlobalPropertiesFunction as e };

package/dist/shared/@databuddy/{sdk.C8T93n5r.d.ts → sdk.DNing6--.d.ts}

@@ -276,6 +276,14 @@ type PropertiesForEvent<T extends EventName> = T extends keyof EventTypeMap ? Ev
  * Databuddy tracker instance interface
  */
 interface DatabuddyTracker {
+    /**
+     * Current anonymous user ID
+     */
+    anonymousId: string;
+    /**
+     * Current session ID
+     */
+    sessionId: string;
     /**
      * Track a custom event
      */
@@ -333,13 +341,4 @@ type TrackFunction = <T extends EventName>(eventName: T, properties?: Properties
 type ScreenViewFunction = (path?: string, properties?: EventProperties) => void;
 type SetGlobalPropertiesFunction = (properties: EventProperties) => void;
 
-/**
- * <Databuddy /> component for Next.js/React apps
- * Injects the databuddy.js script with all config as data attributes
- * Usage: <Databuddy clientId="..." trackScreenViews trackPerformance ... />
- * Or simply: <Databuddy /> (auto-detects clientId from environment variables)
- */
-declare function Databuddy(props: DatabuddyConfig): null;
-
-export { Databuddy as b };
-export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as c, EventName as d, DataAttributes as e, SetGlobalPropertiesFunction as f };
+export type { BaseEventProperties as B, DatabuddyConfig as D, EventProperties as E, PropertiesForEvent as P, ScreenViewFunction as S, TrackFunction as T, DatabuddyTracker as a, EventTypeMap as b, EventName as c, DataAttributes as d, SetGlobalPropertiesFunction as e };