@clickroom/sdk-js 0.2.0

package/dist/flags.d.ts

@@ -0,0 +1,74 @@
+export type FlagOperator = 'exact' | 'is_not' | 'icontains' | 'gt' | 'lt' | 'is_set';
+export interface PropFilter {
+    key: string;
+    operator: FlagOperator;
+    value: unknown;
+}
+export interface Group {
+    properties: PropFilter[];
+    rollout_percentage: number;
+    variant?: string | null;
+}
+export interface Variant {
+    key: string;
+    rollout_percentage: number;
+}
+export interface Multivariate {
+    variants: Variant[];
+}
+export interface Filters {
+    groups: Group[];
+    multivariate?: Multivariate;
+    payloads?: Record<string, unknown>;
+}
+export interface Flag {
+    key: string;
+    active: boolean;
+    filters: Filters;
+}
+export interface FlagResult {
+    enabled: boolean;
+    variant: string | null;
+    payload: unknown;
+}
+/** Deterministic bucket in [0,1): int(sha1(key+"."+distinctId+salt)[0:15]) / 0xFFFFFFFFFFFFFFF. */
+export declare function hashFlag(key: string, distinctId: string, salt: string): number;
+/** actual = person_properties[key]; value = filter value. */
+export declare function propMatch(op: FlagOperator, actual: unknown, value: unknown): boolean;
+/** First matching group wins; in-group-off stops (no fallthrough). */
+export declare function evaluate(flag: Flag, distinctId: string, personProps?: Record<string, unknown>): FlagResult;
+export type FlagMap = Record<string, FlagResult>;
+export interface FlagsResponse {
+    flags: FlagMap;
+}
+export interface FlagClientDeps {
+    getApiHost: () => string;
+    getWriteKey: () => string;
+    getDistinctId: () => string;
+    getPersonProperties: () => Record<string, unknown>;
+}
+export interface FlagClient {
+    /** In-memory cache of the last evaluated flags (or restored from localStorage). */
+    getCache(): FlagMap;
+    isFeatureEnabled(key: string): boolean;
+    getFeatureFlag(key: string): boolean | string;
+    getFeatureFlagPayload(key: string): unknown;
+    /** Fetch + cache flags for the current distinct id/props. Never throws. */
+    fetchFlags(): Promise<FlagMap>;
+    /**
+     * Cheap version check (GET `{apiHost}/flags/version`) before paying for a
+     * full `fetchFlags()`. Only calls `fetchFlags()` (and updates the stored
+     * `lastVersion`) when the returned version differs from the last one seen
+     * — or on the very first check. Network/parse failure on the version check
+     * fails open (treated as "changed") and falls through to a full fetch,
+     * matching this client's existing never-throw/best-effort tolerance.
+     * Never throws.
+     */
+    checkVersionAndMaybeFetch(): Promise<{
+        changed: boolean;
+        flags: FlagMap;
+    }>;
+    /** Drop the in-memory + persisted cache. */
+    clear(): void;
+}
+export declare function createFlagClient(deps: FlagClientDeps): FlagClient;

package/dist/global.d.ts

@@ -0,0 +1,7 @@
+import clickroom from './index';
+declare global {
+    interface Window {
+        clickroom: typeof clickroom;
+    }
+}
+export default clickroom;

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+import type { AutocaptureContext, ClickroomConfig, ClickroomOptions, EventPayload } from './types';
+export declare const PACKAGE_NAME = "@clickroom/sdk-js";
+declare function init(writeKey: string, opts?: ClickroomOptions): void;
+declare function capture(event: string, properties?: Record<string, unknown>): void;
+declare function identify(distinctId: string, personProps?: Record<string, unknown>): void;
+declare function reset(): void;
+declare function isFeatureEnabled(key: string): boolean;
+declare function getFeatureFlag(key: string): boolean | string;
+declare function getFeatureFlagPayload(key: string): unknown;
+declare function onFeatureFlags(cb: (flags: Record<string, boolean | string>) => void): void;
+/** Manually re-fetch flag definitions and notify `onFeatureFlags` listeners.
+ * Same trigger `identify()` already uses internally — exposed directly so a
+ * consumer can refresh on its own signal (a manual "reload flags" button, a
+ * websocket/SSE event from elsewhere, etc.) without faking an identify call. */
+declare function refreshFeatureFlags(): void;
+/** Stop the `feature_flag_poll_interval` loop started in `init()`, if any. */
+declare function stopFeatureFlagPolling(): void;
+declare const clickroom: {
+    init: typeof init;
+    capture: typeof capture;
+    identify: typeof identify;
+    reset: typeof reset;
+    isFeatureEnabled: typeof isFeatureEnabled;
+    getFeatureFlag: typeof getFeatureFlag;
+    getFeatureFlagPayload: typeof getFeatureFlagPayload;
+    onFeatureFlags: typeof onFeatureFlags;
+    refreshFeatureFlags: typeof refreshFeatureFlags;
+    stopFeatureFlagPolling: typeof stopFeatureFlagPolling;
+};
+export type { AutocaptureContext, ClickroomConfig, ClickroomOptions, EventPayload };
+export { capture, getFeatureFlag, getFeatureFlagPayload, identify, init, isFeatureEnabled, onFeatureFlags, refreshFeatureFlags, reset, stopFeatureFlagPolling, };
+export default clickroom;