@lovart-open/flags 0.0.2 → 0.0.3-canary.pr10.fd78749

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1 @@
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/statsig/index.d.ts

@@ -0,0 +1,315 @@
+import z from 'zod';
+import { StatsigOptions, StatsigUser, StatsigClient } from '@statsig/js-client';
+export * from '@statsig/react-bindings';
+
+/**
+ * Core types for the feature flag and parameter store.
+ */
+/**
+ * Statsig Feature Gate type (internal use).
+ */
+interface FeatureGate {
+    value: boolean;
+    idType?: string | null;
+    details?: {
+        reason: string;
+    };
+}
+/**
+ * Statsig evaluation options.
+ */
+interface EvaluationOptions {
+    /** Disable exposure logging */
+    disableExposureLog?: boolean;
+}
+/**
+ * Feature flag definition.
+ */
+interface FlagDefinition {
+    /** Human-readable description */
+    description?: string;
+    /** Fixed value for test/E2E environments */
+    testOverride?: boolean;
+    /** Static override value (higher priority than remote) */
+    override?: boolean;
+    /** Mark as kept locally (no remote config needed) */
+    keep?: boolean;
+}
+/**
+ * Flag value source priority levels.
+ */
+type FlagPriority = 'url' | 'test' | 'override' | 'remote' | 'fallback';
+/**
+ * Flag state with value and source information.
+ */
+interface FlagState {
+    flag: boolean;
+    source: FlagPriority;
+}
+/**
+ * Extract string keys from flag definitions.
+ */
+type FlagKeyOf<TDefinitions extends Record<string, FlagDefinition>> = Extract<keyof TDefinitions, string>;
+/**
+ * Snapshot of all flag states keyed by flag key.
+ */
+type FlagSnapshot<TKey extends string = string> = Record<TKey, FlagState>;
+/**
+ * Remote flag values (boolean map).
+ */
+type RemoteFlagValues<TKey extends string = string> = Partial<Record<TKey, boolean>>;
+
+/**
+ * Feature Flags factory module.
+ * Use createFlagStore to create type-safe flag stores and hooks.
+ */
+
+interface ResolveOptions extends EvaluationOptions {
+    gate?: FeatureGate;
+    search?: string;
+}
+/**
+ * Parse URL query string for flag overrides.
+ * Format: ?ff.flag_name=1 or ?ff.flag_name=true
+ */
+declare function parseUrlOverrides(search?: string): Record<string, boolean>;
+/**
+ * Type-safe FlagStore class.
+ */
+declare class FlagStore<TDefinitions extends Record<string, FlagDefinition>> {
+    private readonly definitions;
+    constructor(definitions: TDefinitions);
+    /** Get snapshot of all flag states */
+    get snapshot(): FlagSnapshot<Extract<keyof TDefinitions, string>>;
+    /** Get flag boolean value */
+    getFlag: <K extends keyof TDefinitions>(key: K, options?: EvaluationOptions) => boolean;
+    /** Get flag state with source info */
+    getFlagState<K extends keyof TDefinitions>(key: K, options?: EvaluationOptions): FlagState;
+    /**
+     * Resolve flag value with priority: URL > test > override > remote > fallback
+     */
+    resolve<K extends keyof TDefinitions>(key: K, options?: ResolveOptions): FlagState;
+}
+/**
+ * Create a type-safe Flag Store with React hooks.
+ *
+ * @example
+ * ```ts
+ * const MY_FLAGS = {
+ *   dark_mode: { description: 'Dark mode toggle' },
+ *   new_checkout: { description: 'New checkout flow' },
+ * } as const satisfies Record<string, FlagDefinition>;
+ *
+ * export const { flagStore, useFlag, useFlagState } = createFlagStore(MY_FLAGS);
+ *
+ * // Full type safety and autocomplete
+ * const isDark = useFlag('dark_mode');  // ✓ autocomplete
+ * useFlag('unknown');                    // ✗ compile error
+ * ```
+ */
+declare function createFlagStore<T extends Record<string, FlagDefinition>>(definitions: T): {
+    /** FlagStore instance */
+    flagStore: FlagStore<T>;
+    /** React Hook: Get flag boolean value */
+    useFlag: (key: Extract<keyof T, string>, options?: EvaluationOptions) => boolean;
+    /** React Hook: Get flag state { flag, source } */
+    useFlagState: (key: Extract<keyof T, string>, options?: EvaluationOptions) => FlagState;
+};
+
+/**
+ * Simple logger interface.
+ */
+type Logger = (message: string, data?: unknown) => void;
+/**
+ * Set a custom logger implementation.
+ */
+declare function setLogger(logger: Logger): void;
+/**
+ * Get the current logger instance.
+ */
+declare function getLogger(): Logger;
+
+/**
+ * Statsig client initialization module.
+ * Provides singleton pattern for StatsigClient.
+ */
+
+/**
+ * Bootstrap data structure for server-side rendering.
+ * Pass this from your BFF/SSR layer to enable zero-network initialization.
+ */
+interface StatsigBootstrap {
+    user?: StatsigUser;
+    data: string;
+}
+interface InitOptions extends StatsigOptions {
+    /**
+     * Test environment indicator.
+     * When true or returns true, testOverride values will be used.
+     *
+     * - `boolean`: static value
+     * - `() => boolean`: dynamic function
+     * - `undefined`: testOverride disabled
+     */
+    isTestEnv?: boolean | (() => boolean);
+    /**
+     * Custom logger implementation.
+     */
+    logger?: Logger;
+    /**
+     * Bootstrap data from server (enables zero-network init).
+     * The data will be set before initializeSync() is called.
+     */
+    bootstrap?: StatsigBootstrap | null;
+}
+/**
+ * Initialize Statsig client (singleton).
+ *
+ * @example
+ * ```ts
+ * // Basic initialization
+ * initStatsigClient('client-xxx', { userID: 'user-123' }, {
+ *   environment: { tier: 'production' },
+ *   isTestEnv: () => Boolean(window.__E2E__),
+ * });
+ *
+ * // With server-side bootstrap (zero network)
+ * initStatsigClient('client-xxx', { userID: 'user-123' }, {
+ *   environment: { tier: 'production' },
+ *   bootstrap: { data: '...' },
+ * });
+ * ```
+ */
+declare function initStatsigClient(clientKey: string, user: StatsigUser, options?: InitOptions): StatsigClient;
+/**
+ * Get Statsig client synchronously.
+ *
+ * @throws Error if not initialized
+ */
+declare function getStatsigClientSync(): StatsigClient;
+/**
+ * Check if currently in test environment.
+ * Returns false if isTestEnv was not configured.
+ */
+declare function isTestEnv(): boolean;
+
+/**
+ * Parameter Stores factory module.
+ * Use createParamStore to create type-safe parameter stores and hooks.
+ */
+
+/** Parameter definition */
+interface ParamDefinition<T = unknown> {
+    schema: z.ZodType<T>;
+    fallback: T;
+    description?: string;
+    testOverride?: T;
+    override?: T;
+}
+/** Parameter store definition */
+interface ParamStoreDefinition<TParams extends Record<string, ParamDefinition<any>>> {
+    description?: string;
+    keep?: boolean;
+    params: TParams;
+}
+/** Helper function to define a single param with type inference */
+declare function defineParam<T>(def: ParamDefinition<T>): ParamDefinition<T>;
+/** Event name for schema mismatch errors */
+declare const PARAM_SCHEMA_MISMATCH_EVENT = "param-schema-mismatch";
+/** Detail payload for schema mismatch event */
+interface ParamSchemaMismatchDetail {
+    storeKey: string;
+    paramKey: string;
+    source: string;
+    value: unknown;
+    error: z.ZodError;
+}
+/**
+ * Parse URL query string for param store overrides (standalone function).
+ * Format: ?fp.store.param=value or ?fp.store={"param":"value"}
+ *
+ * @example
+ * parseParamStoreUrlOverrides('?fp.config.debug=true')
+ * // => { config: { debug: true } }
+ */
+declare function parseParamStoreUrlOverrides(search?: string): Record<string, Record<string, unknown>>;
+/** Single param state with value and source */
+interface ParamState<T> {
+    value: T;
+    source: 'url' | 'test' | 'override' | 'remote' | 'fallback';
+    error?: z.ZodError;
+    fallback?: T;
+}
+/** Store handle for accessing params */
+interface ParamStoreHandle<TParams extends Record<string, ParamDefinition<any>>> {
+    get<P extends keyof TParams>(paramKey: P): z.infer<TParams[P]['schema']>;
+    getState<P extends keyof TParams>(paramKey: P): ParamState<z.infer<TParams[P]['schema']>>;
+}
+/** Infer value types from param definitions */
+type ParamStoreValue<TParams extends Record<string, ParamDefinition<any>>> = {
+    [K in keyof TParams]: z.infer<TParams[K]['schema']>;
+};
+/** Statsig ParameterStore return type */
+type StatsigParameterStore = ReturnType<ReturnType<typeof getStatsigClientSync>['getParameterStore']>;
+/** Resolve options for param lookup */
+interface ParamResolveOptions {
+    statsigStore?: StatsigParameterStore | null;
+    search?: string;
+    disableExposureLog?: boolean;
+}
+/**
+ * Type-safe ParamStore class.
+ */
+declare class ParamStore<TStores extends Record<string, ParamStoreDefinition<any>>> {
+    private readonly definitions;
+    constructor(definitions: TStores);
+    /**
+     * Parse URL query string for param overrides.
+     * Format: ?fp.store.param=value or ?fp.store={"param":"value"}
+     */
+    private parseUrlOverrides;
+    /**
+     * Resolve param value with priority: URL > test > override > remote > fallback
+     */
+    private resolve;
+    /** Get param state with value and source info */
+    getParamState<K extends keyof TStores, P extends keyof TStores[K]['params']>(storeKey: K, paramKey: P, options?: ParamResolveOptions): ParamState<z.infer<TStores[K]['params'][P]['schema']>>;
+    /** Get param value directly */
+    getParam<K extends keyof TStores, P extends keyof TStores[K]['params']>(storeKey: K, paramKey: P, options?: ParamResolveOptions): z.infer<TStores[K]['params'][P]['schema']>;
+    /** Get store handle for multiple param access */
+    getStore<K extends keyof TStores>(storeKey: K, options?: ParamResolveOptions): ParamStoreHandle<TStores[K]['params']>;
+}
+/**
+ * Create a type-safe Param Store with React hooks.
+ *
+ * @example
+ * ```ts
+ * const MY_PARAMS = {
+ *   homepage_cta: {
+ *     description: 'Homepage CTA button',
+ *     params: {
+ *       text: defineParam({ schema: z.string(), fallback: 'Learn More' }),
+ *       color: defineParam({ schema: z.enum(['red', 'blue']), fallback: 'blue' }),
+ *     },
+ *   },
+ * } as const satisfies Record<string, ParamStoreDefinition<any>>;
+ *
+ * export const { paramStore, useParam, useParamState } = createParamStore(MY_PARAMS);
+ *
+ * // Full type safety and autocomplete
+ * const text = useParam('homepage_cta', 'text');   // string type
+ * const color = useParam('homepage_cta', 'color'); // 'red' | 'blue' type
+ * ```
+ */
+declare function createParamStore<T extends Record<string, ParamStoreDefinition<any>>>(definitions: T): {
+    /** ParamStore instance */
+    paramStore: ParamStore<T>;
+    /** React Hook: Get single param value */
+    useParam: <K extends Extract<keyof T, string>, P extends keyof T[K]["params"]>(storeKey: K, paramKey: P, options?: ParamResolveOptions) => z.infer<T[K]["params"][P]["schema"]>;
+    /** React Hook: Get single param state */
+    useParamState: <K extends Extract<keyof T, string>, P extends keyof T[K]["params"]>(storeKey: K, paramKey: P, options?: ParamResolveOptions) => ParamState<z.infer<T[K]["params"][P]["schema"]>>;
+    /** React Hook: Get store handle */
+    useParamStore: <K extends Extract<keyof T, string>>(storeKey: K, options?: ParamResolveOptions) => ParamStoreHandle<T[K]["params"]>;
+};
+
+export { type EvaluationOptions, type FeatureGate, type FlagDefinition, type FlagKeyOf, type FlagPriority, type FlagSnapshot, type FlagState, FlagStore, type InitOptions, type Logger, PARAM_SCHEMA_MISMATCH_EVENT, type ParamDefinition, type ParamResolveOptions, type ParamSchemaMismatchDetail, type ParamState, ParamStore, type ParamStoreDefinition, type ParamStoreHandle, type ParamStoreValue, type RemoteFlagValues, type ResolveOptions, type StatsigBootstrap, createFlagStore, createParamStore, defineParam, getLogger, getStatsigClientSync, initStatsigClient, isTestEnv, parseParamStoreUrlOverrides, parseUrlOverrides, setLogger };

package/dist/statsig/index.js

@@ -0,0 +1,379 @@
+// src/statsig/flags.ts
+import { useFeatureGate } from "@statsig/react-bindings";
+
+// src/statsig/client.ts
+import { StatsigClient } from "@statsig/js-client";
+
+// src/statsig/logger.ts
+var defaultLogger = (message, data) => {
+  if (data !== void 0) {
+    console.info(`[statsig] ${message}`, data);
+  } else {
+    console.info(`[statsig] ${message}`);
+  }
+};
+var currentLogger = defaultLogger;
+function setLogger(logger) {
+  currentLogger = logger;
+}
+function getLogger() {
+  return currentLogger;
+}
+
+// src/statsig/client.ts
+var client = null;
+var testEnvDetector = null;
+function initStatsigClient(clientKey, user, options) {
+  if (client) return client;
+  const { isTestEnv: isTestEnv2, logger, bootstrap, ...statsigOptions } = options ?? {};
+  if (logger) {
+    setLogger(logger);
+  }
+  const log = getLogger();
+  if (typeof isTestEnv2 === "function") {
+    testEnvDetector = isTestEnv2;
+  } else if (typeof isTestEnv2 === "boolean") {
+    testEnvDetector = () => isTestEnv2;
+  }
+  if (bootstrap) {
+    log(`Initializing with bootstrap data (userID: '${user.userID}')`);
+  } else {
+    log(`Initializing in default mode (userID: '${user.userID}')`);
+  }
+  client = new StatsigClient(clientKey, user, statsigOptions);
+  if (bootstrap?.data) {
+    client.dataAdapter.setData(bootstrap.data);
+  }
+  client.initializeSync();
+  return client;
+}
+function getStatsigClientSync() {
+  if (!client) {
+    throw new Error("[@lovart-open/flags/statsig] Not initialized. Call initStatsigClient() first.");
+  }
+  return client;
+}
+function isTestEnv() {
+  return testEnvDetector?.() ?? false;
+}
+
+// src/statsig/flags.ts
+var TRUE_LITERALS = /* @__PURE__ */ new Set(["1", "true"]);
+var hasWindow = typeof window !== "undefined";
+function parseUrlOverrides(search) {
+  if (!hasWindow && !search) return {};
+  const searchString = search ?? (hasWindow ? window.location.search : "");
+  const params = new URLSearchParams(searchString);
+  const overrides = {};
+  for (const [key, value] of params.entries()) {
+    if (key.startsWith("ff.")) {
+      overrides[key.slice(3)] = TRUE_LITERALS.has(value.trim().toLowerCase());
+    }
+  }
+  return overrides;
+}
+var FlagStore = class {
+  constructor(definitions) {
+    /** Get flag boolean value */
+    this.getFlag = (key, options) => this.getFlagState(key, options).flag;
+    this.definitions = definitions;
+  }
+  /** Get snapshot of all flag states */
+  get snapshot() {
+    const next = {};
+    for (const key in this.definitions) {
+      next[key] = this.resolve(key);
+    }
+    return next;
+  }
+  /** Get flag state with source info */
+  getFlagState(key, options) {
+    return this.resolve(key, options);
+  }
+  /**
+   * Resolve flag value with priority: URL > test > override > remote > fallback
+   */
+  resolve(key, options) {
+    const { gate, search, ...evaluationOptions } = options ?? {};
+    const def = this.definitions[key];
+    if (!def) return { flag: false, source: "fallback" };
+    const keyStr = key;
+    const urlOverrides = parseUrlOverrides(search);
+    if (urlOverrides[keyStr] !== void 0) {
+      return { flag: urlOverrides[keyStr], source: "url" };
+    }
+    if (isTestEnv() && def.testOverride !== void 0) {
+      return { flag: def.testOverride, source: "test" };
+    }
+    if (def.override !== void 0) {
+      return { flag: def.override, source: "override" };
+    }
+    try {
+      const currentGate = gate ?? getStatsigClientSync().getFeatureGate(keyStr, evaluationOptions);
+      return {
+        flag: currentGate.value,
+        source: currentGate.idType ? "remote" : "fallback"
+      };
+    } catch {
+      return { flag: false, source: "fallback" };
+    }
+  }
+};
+function createFlagStore(definitions) {
+  const store = new FlagStore(definitions);
+  function useFlagState(key, options) {
+    const featureGate = useFeatureGate(key, options);
+    return store.resolve(key, { gate: featureGate, ...options });
+  }
+  function useFlag(key, options) {
+    const featureGate = useFeatureGate(key, options);
+    return store.resolve(key, { gate: featureGate, ...options }).flag;
+  }
+  return {
+    /** FlagStore instance */
+    flagStore: store,
+    /** React Hook: Get flag boolean value */
+    useFlag,
+    /** React Hook: Get flag state { flag, source } */
+    useFlagState
+  };
+}
+
+// src/statsig/params.ts
+import { merge, set } from "lodash-es";
+import { useParameterStore } from "@statsig/react-bindings";
+function defineParam(def) {
+  return def;
+}
+var hasWindow2 = typeof window !== "undefined";
+var FP_PREFIX = "fp.";
+var PARAM_SCHEMA_MISMATCH_EVENT = "param-schema-mismatch";
+function dispatchSchemaMismatchEvent(detail) {
+  if (!hasWindow2) return;
+  window.dispatchEvent(new CustomEvent(PARAM_SCHEMA_MISMATCH_EVENT, { detail }));
+}
+function parseParamStoreUrlOverrides(search) {
+  const searchString = search ?? (hasWindow2 ? window.location.search : "");
+  const params = new URLSearchParams(searchString);
+  const result = {};
+  for (const [key, value] of params.entries()) {
+    if (!key.startsWith(FP_PREFIX)) continue;
+    const rest = key.slice(FP_PREFIX.length);
+    const dotIndex = rest.indexOf(".");
+    if (dotIndex >= 0) {
+      const path = rest;
+      const coerced = tryCoerceBasic(value);
+      set(result, path, coerced);
+    } else {
+      const path = rest;
+      try {
+        const obj = JSON.parse(value);
+        if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+          result[path] = merge(result[path] ?? {}, obj);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function tryCoerceBasic(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  const num = Number(raw);
+  if (!Number.isNaN(num) && raw !== "") return num;
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  if (raw === "null") return null;
+  return raw;
+}
+function tryCoerce(raw, def) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+    }
+  }
+  if (def?.schema) {
+    const num = Number(raw);
+    if (!Number.isNaN(num) && def.schema.safeParse(num).success) {
+      return num;
+    }
+    if (raw === "true" && def.schema.safeParse(true).success) return true;
+    if (raw === "false" && def.schema.safeParse(false).success) return false;
+    if (raw === "null" && def.schema.safeParse(null).success) return null;
+  }
+  return raw;
+}
+var ParamStore = class {
+  constructor(definitions) {
+    this.definitions = definitions;
+  }
+  /**
+   * Parse URL query string for param overrides.
+   * Format: ?fp.store.param=value or ?fp.store={"param":"value"}
+   */
+  parseUrlOverrides(search) {
+    const searchString = search ?? (hasWindow2 ? window.location.search : "");
+    const params = new URLSearchParams(searchString);
+    const result = {};
+    for (const [key, value] of params.entries()) {
+      if (!key.startsWith(FP_PREFIX)) continue;
+      const rest = key.slice(FP_PREFIX.length);
+      const dotIndex = rest.indexOf(".");
+      if (dotIndex >= 0) {
+        const path = rest;
+        const storeKey = rest.slice(0, dotIndex);
+        const paramKey = rest.slice(dotIndex + 1);
+        const storeDef = this.definitions[storeKey];
+        const paramDef = storeDef?.params[paramKey];
+        set(result, path, tryCoerce(value, paramDef));
+      } else {
+        const path = rest;
+        try {
+          const obj = JSON.parse(value);
+          if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
+            result[path] = merge(result[path] ?? {}, obj);
+          }
+        } catch {
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve param value with priority: URL > test > override > remote > fallback
+   */
+  resolve(storeKey, paramKey, options) {
+    const { statsigStore, search, ...evaluationOptions } = options ?? {};
+    const storeDef = this.definitions[storeKey];
+    if (!storeDef) {
+      throw new Error(`[ParamStore] Unknown store: ${String(storeKey)}`);
+    }
+    const def = storeDef.params[paramKey];
+    if (!def) {
+      throw new Error(`[ParamStore] Unknown param: ${String(storeKey)}.${String(paramKey)}`);
+    }
+    const schema = def.schema;
+    let value;
+    let source;
+    const urlOverrides = this.parseUrlOverrides(search);
+    const urlVal = urlOverrides[storeKey]?.[paramKey];
+    if (urlVal !== void 0) {
+      value = urlVal;
+      source = "url";
+    } else if (isTestEnv() && def.testOverride !== void 0) {
+      value = def.testOverride;
+      source = "test";
+    } else if (def.override !== void 0) {
+      value = def.override;
+      source = "override";
+    } else {
+      try {
+        const clientStore = statsigStore ?? getStatsigClientSync().getParameterStore(storeKey, evaluationOptions);
+        const config = clientStore?.__configuration?.[paramKey];
+        if (config !== void 0) {
+          value = clientStore.get(paramKey, def.fallback);
+          source = "remote";
+        } else {
+          value = def.fallback;
+          source = "fallback";
+        }
+      } catch {
+        value = def.fallback;
+        source = "fallback";
+      }
+    }
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+      console.error(`[ParamStore] Schema mismatch (${source}): ${String(storeKey)}.${String(paramKey)}`, value, parsed.error);
+      dispatchSchemaMismatchEvent({
+        storeKey: String(storeKey),
+        paramKey: String(paramKey),
+        source,
+        value,
+        error: parsed.error
+      });
+      const fallbackVal = def.fallback;
+      if (source === "remote") {
+        return { value: fallbackVal, source: "fallback", error: parsed.error };
+      }
+      return { value, source, error: parsed.error, fallback: fallbackVal };
+    }
+    return { value: parsed.data, source };
+  }
+  /** Get param state with value and source info */
+  getParamState(storeKey, paramKey, options) {
+    return this.resolve(storeKey, paramKey, options);
+  }
+  /** Get param value directly */
+  getParam(storeKey, paramKey, options) {
+    return this.resolve(storeKey, paramKey, options).value;
+  }
+  /** Get store handle for multiple param access */
+  getStore(storeKey, options) {
+    const { statsigStore, ...rest } = options ?? {};
+    let cachedStore = statsigStore;
+    if (cachedStore === void 0) {
+      try {
+        cachedStore = getStatsigClientSync().getParameterStore(storeKey, rest);
+      } catch {
+        cachedStore = null;
+      }
+    }
+    const opts = { ...rest, statsigStore: cachedStore };
+    return {
+      get: (paramKey) => this.resolve(storeKey, paramKey, opts).value,
+      getState: (paramKey) => this.resolve(storeKey, paramKey, opts)
+    };
+  }
+};
+function createParamStore(definitions) {
+  const store = new ParamStore(definitions);
+  function useParamStore(storeKey, options) {
+    const statsigStore = useParameterStore(storeKey, options);
+    return store.getStore(storeKey, { ...options, statsigStore });
+  }
+  function useParamState(storeKey, paramKey, options) {
+    const statsigStore = useParameterStore(storeKey, options);
+    return store.getParamState(storeKey, paramKey, { ...options, statsigStore });
+  }
+  function useParam(storeKey, paramKey, options) {
+    return useParamState(storeKey, paramKey, options).value;
+  }
+  return {
+    /** ParamStore instance */
+    paramStore: store,
+    /** React Hook: Get single param value */
+    useParam,
+    /** React Hook: Get single param state */
+    useParamState,
+    /** React Hook: Get store handle */
+    useParamStore
+  };
+}
+
+// src/statsig/index.ts
+export * from "@statsig/react-bindings";
+export {
+  FlagStore,
+  PARAM_SCHEMA_MISMATCH_EVENT,
+  ParamStore,
+  createFlagStore,
+  createParamStore,
+  defineParam,
+  getLogger,
+  getStatsigClientSync,
+  initStatsigClient,
+  isTestEnv,
+  parseParamStoreUrlOverrides,
+  parseUrlOverrides,
+  setLogger
+};
+//# sourceMappingURL=index.js.map