@growth-loop/sdk 0.1.1

package/dist/client-CC-8sBba.d.ts

@@ -0,0 +1,60 @@
+import { Properties, EventContext, IngestPayload } from '@growth/shared';
+
+interface Transport {
+    send(url: string, payload: IngestPayload, headers: Record<string, string>): Promise<void>;
+}
+interface GrowthOptions {
+    apiKey: string;
+    host?: string;
+    flushInterval?: number;
+    batchSize?: number;
+    defaultContext?: EventContext;
+    transport?: Transport;
+    onError?: (error: Error) => void;
+    debug?: boolean;
+}
+interface TrackOptions {
+    distinctId?: string;
+    timestamp?: Date;
+    context?: EventContext;
+}
+interface IdentifyOptions {
+    distinctId: string;
+    properties?: Properties;
+    context?: EventContext;
+}
+interface GrowthClient {
+    track(name: string, properties?: Properties, options?: TrackOptions): void;
+    identify(options: IdentifyOptions): void;
+    alias(distinctId: string, previousId: string): void;
+    group(groupType: string, groupKey: string, properties?: Properties): void;
+    setContext(context: EventContext): void;
+    setDistinctId(id: string): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+declare function createClient(options: GrowthOptions): GrowthClient;
+declare class Growth implements GrowthClient {
+    private readonly apiKey;
+    private readonly host;
+    private readonly transport;
+    private readonly queue;
+    private readonly onError;
+    private readonly debug;
+    private context;
+    private distinctId;
+    private flushTimer;
+    private closed;
+    constructor(options: GrowthOptions);
+    setDistinctId(id: string): void;
+    setContext(context: EventContext): void;
+    track(name: string, properties?: Properties, options?: TrackOptions): void;
+    identify(options: IdentifyOptions): void;
+    alias(distinctId: string, previousId: string): void;
+    group(groupType: string, groupKey: string, properties?: Properties): void;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    private send;
+}
+
+export { type GrowthClient as G, type IdentifyOptions as I, type TrackOptions as T, Growth as a, type GrowthOptions as b, type Transport as c, createClient as d };

package/dist/index.d.ts

@@ -0,0 +1,61 @@
+import { G as GrowthClient, T as TrackOptions } from './client-CC-8sBba.js';
+export { a as Growth, b as GrowthOptions, I as IdentifyOptions, c as Transport, d as createClient } from './client-CC-8sBba.js';
+import { Properties } from '@growth/shared';
+export { EventContext, Properties, TrackEvent } from '@growth/shared';
+
+/**
+ * Higher-level instrumentation: spans, steps, tracked clicks.
+ *
+ * These wrap the low-level `track()` API in patterns the agent (and a human)
+ * can drop into existing code with minimal change. Designed to be applied
+ * automatically by `claude /growth init`.
+ *
+ *   const checkout = growth.span('checkout', async () => { ... });
+ *   const onLogin = growth.button('login_clicked', () => doLogin());
+ *   growth.step('activation.invited_team', { team_id });
+ */
+
+interface SpanOptions extends TrackOptions {
+    /** Static properties merged into both started/completed/failed events. */
+    properties?: Properties;
+    /** Optional dynamic property extractor — runs with the function args (or result on success). */
+    enrich?: (args: unknown[], phase: 'start' | 'success' | 'failure', result?: unknown) => Properties | undefined;
+}
+/**
+ * Wraps an async or sync function so it emits start + completed events with
+ * latency, plus a failed event on throw. Returns a function with the same
+ * signature.
+ *
+ * Naming convention: emits `<name>.started`, `<name>.completed`, `<name>.failed`.
+ */
+declare function span<TArgs extends unknown[], TRet>(growth: GrowthClient, name: string, fn: (...args: TArgs) => TRet | Promise<TRet>, options?: SpanOptions): (...args: TArgs) => Promise<TRet>;
+/**
+ * Marks one funnel step. Cheaper than span — single event, no timing.
+ *
+ *   growth.step('onboarding.completed_setup');
+ *   growth.step('signup.passed_email_verification', { email_domain });
+ */
+declare function step(growth: GrowthClient, funnelStep: string, properties?: Properties, options?: TrackOptions): void;
+/**
+ * Wraps an event handler (e.g. button onClick) so the click is logged before
+ * the handler fires. Synchronous and reentrant-safe.
+ *
+ *   <button onClick={growth.button('login_clicked', onLogin)}>Login</button>
+ */
+declare function button<TArgs extends unknown[], TRet>(growth: GrowthClient, name: string, handler?: (...args: TArgs) => TRet, properties?: Properties): (...args: TArgs) => TRet | undefined;
+/**
+ * Adds the helpers above as methods on a Growth client instance. Call once
+ * after constructing the client and the API surface becomes:
+ *
+ *   const growth = createBrowserClient({ apiKey, host });
+ *   instrument(growth);
+ *   growth.span('checkout', fn);  // ✓ now available
+ */
+interface GrowthInstrumented extends GrowthClient {
+    span: <TArgs extends unknown[], TRet>(name: string, fn: (...args: TArgs) => TRet | Promise<TRet>, options?: SpanOptions) => (...args: TArgs) => Promise<TRet>;
+    step: (funnelStep: string, properties?: Properties, options?: TrackOptions) => void;
+    button: <TArgs extends unknown[], TRet>(name: string, handler?: (...args: TArgs) => TRet, properties?: Properties) => (...args: TArgs) => TRet | undefined;
+}
+declare function instrument(growth: GrowthClient): GrowthInstrumented;
+
+export { GrowthClient, type GrowthInstrumented, type SpanOptions, TrackOptions, button, instrument, span, step };