@launchwhitly/sdk 0.1.3

package/dist/client.d.ts

@@ -0,0 +1,34 @@
+import { evaluate } from './rollout';
+import type { EvalContext, EvaluateResult, FlagState } from './types';
+import type { BootstrapResponse, LaunchwhitlyClientOptions, SnapshotListener } from './types';
+type ClientSnapshot = BootstrapResponse;
+export declare class LaunchwhitlyClient {
+    private readonly baseUrl;
+    private readonly projectKey;
+    private readonly environmentKey;
+    private readonly fetchImpl;
+    private readonly pollingIntervalMs;
+    private readonly reconnectDelayMs;
+    private snapshot;
+    private listeners;
+    private closed;
+    private started;
+    private initPromise;
+    private streamAbortController;
+    private pollAbortController;
+    constructor(options: LaunchwhitlyClientOptions);
+    init(): Promise<ClientSnapshot>;
+    getSnapshot(): ClientSnapshot | null;
+    getFlag(flagKey: string): FlagState | undefined;
+    evaluate(flagKey: string, context: EvalContext): EvaluateResult;
+    evaluateAll(context: EvalContext): Record<string, ReturnType<typeof evaluate>>;
+    subscribe(listener: SnapshotListener): () => void;
+    refresh(): Promise<ClientSnapshot>;
+    close(): void;
+    private setSnapshot;
+    private runStreamLoop;
+    private runPollLoop;
+}
+export declare function createClient(options: LaunchwhitlyClientOptions): LaunchwhitlyClient;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,WAAW,CAAA;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAa,SAAS,EAAE,MAAM,SAAS,CAAA;AAChF,OAAO,KAAK,EACV,iBAAiB,EACjB,yBAAyB,EACzB,gBAAgB,EACjB,MAAM,SAAS,CAAA;AAGhB,KAAK,cAAc,GAAG,iBAAiB,CAAA;AAwCvC,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;IAC1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAQ;IACzC,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,SAAS,CAA8B;IAC/C,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,OAAO,CAAQ;IACvB,OAAO,CAAC,WAAW,CAAuC;IAC1D,OAAO,CAAC,qBAAqB,CAA+B;IAC5D,OAAO,CAAC,mBAAmB,CAA+B;gBAE9C,OAAO,EAAE,yBAAyB;IASxC,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC;IAqBrC,WAAW,IAAI,cAAc,GAAG,IAAI;IAIpC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS;IAI/C,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,cAAc;IAM/D,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;IAK9E,SAAS,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,IAAI;IAU3C,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAWxC,KAAK;IAOL,OAAO,CAAC,WAAW;YAWL,aAAa;YAiDb,WAAW;CAmB1B;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,yBAAyB,sBAE9D"}

package/dist/client.js

@@ -0,0 +1,179 @@
+import { evaluate, evaluateAll } from './rollout';
+import { buildUrl, openEventStream, requestJson } from './transport';
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => resolve(), ms);
+        if (!signal)
+            return;
+        const abortHandler = () => {
+            clearTimeout(timeout);
+            reject(new DOMException('Aborted', 'AbortError'));
+        };
+        if (signal.aborted) {
+            abortHandler();
+            return;
+        }
+        signal.addEventListener('abort', abortHandler, { once: true });
+    });
+}
+function makeHeaders(projectKey, environmentKey, lastEventId) {
+    const headers = new Headers({
+        accept: 'application/json',
+        'x-launchwhitly-project-key': projectKey,
+        'x-launchwhitly-environment-key': environmentKey,
+    });
+    if (lastEventId !== undefined) {
+        headers.set('last-event-id', String(lastEventId));
+    }
+    return headers;
+}
+export class LaunchwhitlyClient {
+    constructor(options) {
+        this.snapshot = null;
+        this.listeners = new Set();
+        this.closed = false;
+        this.started = false;
+        this.initPromise = null;
+        this.streamAbortController = null;
+        this.pollAbortController = null;
+        this.baseUrl = options.baseUrl;
+        this.projectKey = options.projectKey;
+        this.environmentKey = options.environmentKey;
+        this.fetchImpl = options.fetchImpl ?? fetch;
+        this.pollingIntervalMs = options.pollingIntervalMs ?? 30000;
+        this.reconnectDelayMs = options.reconnectDelayMs ?? 2000;
+    }
+    async init() {
+        if (this.started && this.snapshot)
+            return this.snapshot;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = (async () => {
+            const snapshot = await this.refresh();
+            this.started = true;
+            if (!this.closed) {
+                void this.runStreamLoop();
+                void this.runPollLoop();
+            }
+            return snapshot;
+        })();
+        try {
+            return await this.initPromise;
+        }
+        finally {
+            this.initPromise = null;
+        }
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    getFlag(flagKey) {
+        return this.snapshot?.cache.flags[flagKey];
+    }
+    evaluate(flagKey, context) {
+        const flag = this.getFlag(flagKey);
+        if (!flag || !this.snapshot)
+            return null;
+        return evaluate(flag, context, this.snapshot.cache.segments);
+    }
+    evaluateAll(context) {
+        if (!this.snapshot)
+            return {};
+        return evaluateAll(this.snapshot.cache.flags, context, this.snapshot.cache.segments);
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        if (this.snapshot)
+            listener(this.snapshot);
+        void this.init().catch(() => undefined);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    async refresh() {
+        const url = buildUrl(this.baseUrl, '/api/v1/sdk/config');
+        const snapshot = await requestJson(this.fetchImpl, url, {
+            method: 'GET',
+            headers: makeHeaders(this.projectKey, this.environmentKey),
+        });
+        this.setSnapshot(snapshot);
+        return snapshot;
+    }
+    close() {
+        this.closed = true;
+        this.streamAbortController?.abort();
+        this.pollAbortController?.abort();
+        this.listeners.clear();
+    }
+    setSnapshot(snapshot) {
+        const previousVersion = this.snapshot?.cache.version ?? 0;
+        this.snapshot = snapshot;
+        if (snapshot.cache.version <= previousVersion)
+            return;
+        for (const listener of this.listeners) {
+            listener(snapshot);
+        }
+    }
+    async runStreamLoop() {
+        while (!this.closed) {
+            this.streamAbortController?.abort();
+            this.streamAbortController = new AbortController();
+            try {
+                await openEventStream(this.fetchImpl, buildUrl(this.baseUrl, '/api/v1/sdk/stream'), {
+                    method: 'GET',
+                    signal: this.streamAbortController.signal,
+                    headers: makeHeaders(this.projectKey, this.environmentKey, this.snapshot?.cache.version),
+                }, (event) => {
+                    if (event.event !== 'config' || !event.data)
+                        return;
+                    const cache = JSON.parse(event.data);
+                    this.setSnapshot({
+                        project: this.snapshot?.project ?? {
+                            id: '',
+                            name: '',
+                            slug: '',
+                            sdkKeyPrefix: '',
+                        },
+                        environment: this.snapshot?.environment ?? {
+                            id: cache.environmentId,
+                            name: '',
+                            slug: '',
+                            color: '',
+                            sdkKeyPrefix: '',
+                        },
+                        cache,
+                    });
+                });
+            }
+            catch {
+                if (this.closed)
+                    return;
+            }
+            if (this.closed)
+                return;
+            await sleep(this.reconnectDelayMs, this.streamAbortController.signal).catch(() => undefined);
+        }
+    }
+    async runPollLoop() {
+        this.pollAbortController = new AbortController();
+        while (!this.closed) {
+            try {
+                await sleep(this.pollingIntervalMs, this.pollAbortController.signal);
+            }
+            catch {
+                return;
+            }
+            if (this.closed)
+                return;
+            try {
+                await this.refresh();
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+}
+export function createClient(options) {
+    return new LaunchwhitlyClient(options);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createClient, LaunchwhitlyClient } from './client';
+export type { BootstrapResponse, LaunchwhitlyClientOptions, SnapshotListener, EvalContext, EvalResult, FlagCache, FlagState, } from './types';
+export { evaluate, evaluateAll, getBucket, matchesSegment, } from './rollout';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC3D,YAAY,EACV,iBAAiB,EACjB,yBAAyB,EACzB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,GACV,MAAM,SAAS,CAAA;AAChB,OAAO,EACL,QAAQ,EACR,WAAW,EACX,SAAS,EACT,cAAc,GACf,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { createClient, LaunchwhitlyClient } from './client';
+export { evaluate, evaluateAll, getBucket, matchesSegment, } from './rollout';

package/dist/rollout/bucketing.d.ts

@@ -0,0 +1,2 @@
+export declare function getBucket(userId: string, flagKey: string): number;
+//# sourceMappingURL=bucketing.d.ts.map

package/dist/rollout/bucketing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bucketing.d.ts","sourceRoot":"","sources":["../../src/rollout/bucketing.ts"],"names":[],"mappings":"AAcA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAGjE"}

package/dist/rollout/bucketing.js

@@ -0,0 +1,15 @@
+const FNV_OFFSET_BASIS = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+function fnv1a32(input) {
+    let hash = FNV_OFFSET_BASIS;
+    for (let i = 0; i < input.length; i += 1) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, FNV_PRIME);
+    }
+    return hash;
+}
+export function getBucket(userId, flagKey) {
+    if (!userId || !flagKey)
+        return 0;
+    return (fnv1a32(`${userId}:${flagKey}`) >>> 0) % 100;
+}

package/dist/rollout/evaluator.d.ts

@@ -0,0 +1,4 @@
+import type { EvalContext, EvalResult, FlagState, SegmentDef } from './types';
+export declare function evaluate(flag: FlagState, context: EvalContext, segments?: Record<string, SegmentDef>): EvalResult;
+export declare function evaluateAll(flags: Record<string, FlagState>, context: EvalContext, segments?: Record<string, SegmentDef>): Record<string, EvalResult>;
+//# sourceMappingURL=evaluator.d.ts.map

package/dist/rollout/evaluator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluator.d.ts","sourceRoot":"","sources":["../../src/rollout/evaluator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAW,MAAM,SAAS,CAAA;AAkCtF,wBAAgB,QAAQ,CACtB,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,WAAW,EACpB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,GACxC,UAAU,CAsDZ;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAChC,OAAO,EAAE,WAAW,EACpB,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAM,GACxC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAgB5B"}

package/dist/rollout/evaluator.js

@@ -0,0 +1,90 @@
+import { getBucket } from './bucketing';
+import { evaluateRule } from './targeting';
+function disabledResult(defaultValue, reason) {
+    return { enabled: false, value: defaultValue, reason };
+}
+function variantResult(variant) {
+    return {
+        enabled: true,
+        value: variant.value,
+        reason: 'targeting_match',
+        variant: variant.key,
+    };
+}
+function pickVariant(variants, bucket) {
+    if (variants.length === 0)
+        return undefined;
+    const totalWeight = variants.reduce((sum, variant) => sum + (variant.weight ?? 0), 0);
+    if (totalWeight <= 0)
+        return undefined;
+    const scaledBucket = (bucket / 100) * totalWeight;
+    let cursor = 0;
+    for (const variant of variants) {
+        cursor += variant.weight ?? 0;
+        if (scaledBucket < cursor)
+            return variant;
+    }
+    return [...variants].reverse().find((variant) => (variant.weight ?? 0) > 0);
+}
+export function evaluate(flag, context, segments = {}) {
+    if (!flag.enabled)
+        return disabledResult(flag.defaultValue, 'flag_disabled');
+    const bucket = getBucket(context.userId, flag.flagKey);
+    void segments;
+    let forceGlobalRollout = false;
+    for (const rule of flag.rules) {
+        if (!evaluateRule(rule, context))
+            continue;
+        if (rule.rolloutPct !== undefined && rule.rolloutPct !== null && bucket >= rule.rolloutPct) {
+            continue;
+        }
+        if (rule.serve === 'off') {
+            return disabledResult(flag.defaultValue, 'targeting_match');
+        }
+        if (rule.serve === 'on') {
+            forceGlobalRollout = true;
+            break;
+        }
+        const matchedVariant = flag.variants.find((variant) => variant.key === rule.serve);
+        if (matchedVariant)
+            return variantResult(matchedVariant);
+        return {
+            enabled: true,
+            value: flag.defaultValue,
+            reason: 'targeting_match',
+            variant: rule.serve,
+        };
+    }
+    if (!forceGlobalRollout && bucket >= flag.rolloutPct) {
+        return disabledResult(flag.defaultValue, 'rollout');
+    }
+    if (flag.variants.length > 0) {
+        const variant = pickVariant(flag.variants, bucket);
+        if (variant) {
+            return {
+                enabled: true,
+                value: variant.value,
+                reason: 'rollout',
+                variant: variant.key,
+            };
+        }
+        return disabledResult(flag.defaultValue, 'default');
+    }
+    return { enabled: true, value: true, reason: 'default' };
+}
+export function evaluateAll(flags, context, segments = {}) {
+    const results = {};
+    for (const [key, flag] of Object.entries(flags)) {
+        try {
+            results[key] = evaluate(flag, context, segments);
+        }
+        catch {
+            results[key] = {
+                enabled: false,
+                value: flag?.defaultValue ?? null,
+                reason: 'error',
+            };
+        }
+    }
+    return results;
+}

package/dist/rollout/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './bucketing';
+export * from './targeting';
+export * from './segments';
+export * from './evaluator';
+//# sourceMappingURL=index.d.ts.map

package/dist/rollout/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rollout/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA"}

package/dist/rollout/index.js

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './bucketing';
+export * from './targeting';
+export * from './segments';
+export * from './evaluator';

package/dist/rollout/segments.d.ts

@@ -0,0 +1,3 @@
+import type { EvalContext, SegmentDef } from './types';
+export declare function matchesSegment(segment: SegmentDef, context: EvalContext): boolean;
+//# sourceMappingURL=segments.d.ts.map

package/dist/rollout/segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../src/rollout/segments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAGtD,wBAAgB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAGjF"}

package/dist/rollout/segments.js

@@ -0,0 +1,6 @@
+import { evaluateRule } from './targeting';
+export function matchesSegment(segment, context) {
+    if (segment.rules.length === 0)
+        return false;
+    return segment.rules.some((rule) => evaluateRule(rule, context));
+}

package/dist/rollout/targeting.d.ts

@@ -0,0 +1,4 @@
+import type { Condition, EvalContext, TargetingRule } from './types';
+export declare function evaluateCondition(condition: Condition, context: EvalContext): boolean;
+export declare function evaluateRule(rule: TargetingRule, context: EvalContext): boolean;
+//# sourceMappingURL=targeting.d.ts.map

package/dist/rollout/targeting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targeting.d.ts","sourceRoot":"","sources":["../../src/rollout/targeting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAY,aAAa,EAAE,MAAM,SAAS,CAAA;AA4D9E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAMrF;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,WAAW,GAAG,OAAO,CAG/E"}

package/dist/rollout/targeting.js

@@ -0,0 +1,74 @@
+function toStr(value) {
+    if (value === null || value === undefined)
+        return '';
+    return String(value);
+}
+function toNum(value) {
+    if (typeof value === 'number')
+        return value;
+    if (typeof value === 'string')
+        return Number.parseFloat(value);
+    return Number.NaN;
+}
+function looseEqual(a, b) {
+    if (a === null && b === null)
+        return true;
+    if (a === undefined && b === undefined)
+        return true;
+    return a === b;
+}
+function applyOperator(operator, attrValue, conditionValue) {
+    switch (operator) {
+        case 'exists':
+            return attrValue !== undefined && attrValue !== null;
+        case 'not_exists':
+            return attrValue === undefined || attrValue === null;
+        case 'is_true':
+            return attrValue === true;
+        case 'is_false':
+            return attrValue === false;
+        case 'equals':
+            return looseEqual(attrValue, conditionValue);
+        case 'not_equals':
+            return !looseEqual(attrValue, conditionValue);
+        case 'contains':
+            if (Array.isArray(attrValue))
+                return attrValue.some((item) => looseEqual(item, conditionValue));
+            return toStr(conditionValue).length > 0 && toStr(attrValue).includes(toStr(conditionValue));
+        case 'not_contains':
+            if (Array.isArray(attrValue))
+                return !attrValue.some((item) => looseEqual(item, conditionValue));
+            return toStr(conditionValue).length === 0 || !toStr(attrValue).includes(toStr(conditionValue));
+        case 'starts_with':
+            return toStr(conditionValue).length > 0 && toStr(attrValue).startsWith(toStr(conditionValue));
+        case 'ends_with':
+            return toStr(conditionValue).length > 0 && toStr(attrValue).endsWith(toStr(conditionValue));
+        case 'in':
+            return Array.isArray(conditionValue) && conditionValue.some((item) => looseEqual(attrValue, item));
+        case 'not_in':
+            return !Array.isArray(conditionValue) || !conditionValue.some((item) => looseEqual(attrValue, item));
+        case 'gt':
+            return !Number.isNaN(toNum(attrValue)) && !Number.isNaN(toNum(conditionValue)) && toNum(attrValue) > toNum(conditionValue);
+        case 'gte':
+            return !Number.isNaN(toNum(attrValue)) && !Number.isNaN(toNum(conditionValue)) && toNum(attrValue) >= toNum(conditionValue);
+        case 'lt':
+            return !Number.isNaN(toNum(attrValue)) && !Number.isNaN(toNum(conditionValue)) && toNum(attrValue) < toNum(conditionValue);
+        case 'lte':
+            return !Number.isNaN(toNum(attrValue)) && !Number.isNaN(toNum(conditionValue)) && toNum(attrValue) <= toNum(conditionValue);
+        default:
+            return false;
+    }
+}
+export function evaluateCondition(condition, context) {
+    try {
+        return applyOperator(condition.operator, context[condition.attribute], condition.value);
+    }
+    catch {
+        return false;
+    }
+}
+export function evaluateRule(rule, context) {
+    if (rule.conditions.length === 0)
+        return true;
+    return rule.conditions.every((condition) => evaluateCondition(condition, context));
+}

package/dist/rollout/types.d.ts

@@ -0,0 +1,48 @@
+export interface EvalContext {
+    userId: string;
+    [attribute: string]: unknown;
+}
+export type Operator = 'equals' | 'not_equals' | 'contains' | 'not_contains' | 'starts_with' | 'ends_with' | 'in' | 'not_in' | 'gt' | 'gte' | 'lt' | 'lte' | 'is_true' | 'is_false' | 'exists' | 'not_exists';
+export interface Condition {
+    attribute: string;
+    operator: Operator;
+    value: unknown;
+}
+export interface TargetingRule {
+    id: string;
+    conditions: Condition[];
+    serve: 'on' | 'off' | string;
+    rolloutPct?: number;
+}
+export interface Variant {
+    key: string;
+    name: string;
+    weight: number;
+    value: unknown;
+}
+export interface FlagState {
+    flagKey: string;
+    enabled: boolean;
+    rolloutPct: number;
+    rules: TargetingRule[];
+    variants: Variant[];
+    defaultValue: unknown;
+}
+export type EvalReason = 'flag_disabled' | 'targeting_match' | 'rollout' | 'default' | 'error';
+export interface EvalResult {
+    enabled: boolean;
+    value: unknown;
+    reason: EvalReason;
+    variant?: string;
+}
+export interface SegmentDef {
+    key: string;
+    rules: TargetingRule[];
+}
+export interface FlagCache {
+    environmentId: string;
+    version: number;
+    flags: Record<string, FlagState>;
+    segments: Record<string, SegmentDef>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/rollout/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/rollout/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAA;CAC7B;AAED,MAAM,MAAM,QAAQ,GAChB,QAAQ,GACR,YAAY,GACZ,UAAU,GACV,cAAc,GACd,aAAa,GACb,WAAW,GACX,IAAI,GACJ,QAAQ,GACR,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,KAAK,GACL,SAAS,GACT,UAAU,GACV,QAAQ,GACR,YAAY,CAAA;AAEhB,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,QAAQ,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,SAAS,EAAE,CAAA;IACvB,KAAK,EAAE,IAAI,GAAG,KAAK,GAAG,MAAM,CAAA;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,OAAO,CAAA;CACf;AAED,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,aAAa,EAAE,CAAA;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,YAAY,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,MAAM,UAAU,GAClB,eAAe,GACf,iBAAiB,GACjB,SAAS,GACT,SAAS,GACT,OAAO,CAAA;AAEX,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,aAAa,EAAE,CAAA;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACrC"}

package/dist/rollout/types.js

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

package/dist/transport.d.ts

@@ -0,0 +1,10 @@
+export declare function buildUrl(baseUrl: string, path: string, searchParams?: Record<string, string>): URL;
+export declare function requestJson<T>(fetchImpl: typeof fetch, url: URL, init: RequestInit): Promise<T>;
+type StreamEvent = {
+    id: string;
+    event: string;
+    data: string;
+};
+export declare function openEventStream(fetchImpl: typeof fetch, url: URL, init: RequestInit, onEvent: (event: StreamEvent) => void): Promise<void>;
+export {};
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAIA,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAU5F;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,SAAS,EAAE,OAAO,KAAK,EACvB,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,CAAC,CAAC,CAQZ;AAED,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAqFD,wBAAsB,eAAe,CACnC,SAAS,EAAE,OAAO,KAAK,EACvB,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,iBAStC"}

package/dist/transport.js

@@ -0,0 +1,94 @@
+function ensureTrailingSlash(baseUrl) {
+    return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+}
+export function buildUrl(baseUrl, path, searchParams) {
+    const url = new URL(path, ensureTrailingSlash(baseUrl));
+    if (searchParams) {
+        for (const [key, value] of Object.entries(searchParams)) {
+            if (value)
+                url.searchParams.set(key, value);
+        }
+    }
+    return url;
+}
+export async function requestJson(fetchImpl, url, init) {
+    const response = await fetchImpl(url, init);
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(body || `Request failed with status ${response.status}`);
+    }
+    return (await response.json());
+}
+async function readEventStream(response, onEvent) {
+    if (!response.body) {
+        throw new Error('Streaming response does not expose a body');
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let eventName = 'message';
+    let eventId = '';
+    let dataLines = [];
+    const flushEvent = () => {
+        if (dataLines.length === 0 && eventName === 'message' && eventId.length === 0) {
+            return;
+        }
+        onEvent({
+            id: eventId,
+            event: eventName,
+            data: dataLines.join('\n'),
+        });
+        eventName = 'message';
+        eventId = '';
+        dataLines = [];
+    };
+    const consumeLine = (line) => {
+        if (line.length === 0) {
+            flushEvent();
+            return;
+        }
+        if (line.startsWith(':'))
+            return;
+        const separatorIndex = line.indexOf(':');
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+        const value = separatorIndex === -1
+            ? ''
+            : line.slice(separatorIndex + 1).replace(/^ /, '');
+        if (field === 'event') {
+            eventName = value || 'message';
+            return;
+        }
+        if (field === 'id') {
+            eventId = value;
+            return;
+        }
+        if (field === 'data') {
+            dataLines.push(value);
+        }
+    };
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf('\n');
+        while (boundary !== -1) {
+            const line = buffer.slice(0, boundary).replace(/\r$/, '');
+            buffer = buffer.slice(boundary + 1);
+            consumeLine(line);
+            boundary = buffer.indexOf('\n');
+        }
+    }
+    if (buffer.length > 0) {
+        consumeLine(buffer.replace(/\r$/, ''));
+    }
+    flushEvent();
+}
+export async function openEventStream(fetchImpl, url, init, onEvent) {
+    const response = await fetchImpl(url, init);
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        throw new Error(body || `Request failed with status ${response.status}`);
+    }
+    await readEventStream(response, onEvent);
+}

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import type { EvalContext, EvalResult, FlagCache, FlagState } from './rollout';
+export type BootstrapResponse = {
+    project: {
+        id: string;
+        name: string;
+        slug: string;
+        sdkKeyPrefix: string;
+    };
+    environment: {
+        id: string;
+        name: string;
+        slug: string;
+        color: string;
+        sdkKeyPrefix: string;
+    };
+    cache: FlagCache;
+};
+export type LaunchwhitlyClientOptions = {
+    baseUrl: string;
+    projectKey: string;
+    environmentKey: string;
+    fetchImpl?: typeof fetch;
+    pollingIntervalMs?: number;
+    reconnectDelayMs?: number;
+};
+export type SnapshotListener = (snapshot: BootstrapResponse) => void;
+export type EvaluateResult = EvalResult | null;
+export type { EvalContext, EvalResult, FlagCache, FlagState };
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE9E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE;QACP,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;QACZ,YAAY,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,WAAW,EAAE;QACX,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,YAAY,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,KAAK,EAAE,SAAS,CAAA;CACjB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAA;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,CAAA;AAEpE,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,IAAI,CAAA;AAE9C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,CAAA"}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@launchwhitly/sdk",
+  "version": "0.1.3",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "watch": "tsc -p tsconfig.json --watch"
+  }
+}