@oai-statsig/statsig-node-core 0.19.5-beta.2604230102

package/statsig_types.d.ts

@@ -0,0 +1,45 @@
+import { EvaluationDetails, SecondaryExposure } from './statsig-generated';
+export type TypedGet = <T = unknown>(key: string, defaultValue: T, typeGuard?: ((value: unknown) => value is T | null) | null) => T;
+export type UnknownGet = (key: string, fallback?: boolean | number | string | object | Array<any> | null) => unknown | null;
+type RawEvaluation = Record<string, unknown> | string | null;
+declare class BaseEvaluation {
+    readonly name: string;
+    readonly ruleID: string;
+    readonly idType: string;
+    readonly details: EvaluationDetails;
+    readonly secondaryExposures: SecondaryExposure[];
+    constructor(name: string, data: Record<string, unknown>);
+    getEvaluationDetails(): EvaluationDetails;
+    getRuleId(): string;
+    getIdType(): string;
+    getSecondaryExposures(): SecondaryExposure[];
+}
+export declare class FeatureGate extends BaseEvaluation {
+    readonly value: boolean;
+    constructor(name: string, raw: RawEvaluation);
+}
+export declare class DynamicConfig extends BaseEvaluation {
+    readonly value: Record<string, unknown>;
+    readonly get: TypedGet;
+    readonly getValue: UnknownGet;
+    constructor(name: string, raw: RawEvaluation);
+}
+export declare class Experiment extends BaseEvaluation {
+    readonly groupName: string | null;
+    readonly value: Record<string, unknown>;
+    readonly get: TypedGet;
+    readonly getValue: UnknownGet;
+    constructor(name: string, raw: RawEvaluation);
+    getGroupName(): string | null;
+}
+export declare class Layer extends BaseEvaluation {
+    readonly groupName: string | null;
+    readonly allocatedExperimentName: string | null;
+    readonly __value: Record<string, unknown>;
+    readonly get: TypedGet;
+    readonly getValue: UnknownGet;
+    constructor(exposeFn: (param: string) => void, name: string, raw: RawEvaluation);
+    getGroupName(): string | null;
+    getAllocatedExperimentName(): string | null;
+}
+export {};

package/statsig_types.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Layer = exports.Experiment = exports.DynamicConfig = exports.FeatureGate = void 0;
+function _getTypeOf(x) {
+    return Array.isArray(x) ? 'array' : x === null ? 'null' : typeof x;
+}
+class BaseEvaluation {
+    constructor(name, data) {
+        var _a, _b, _c;
+        this.secondaryExposures = [];
+        this.name = name;
+        this.ruleID = (_a = data.ruleID) !== null && _a !== void 0 ? _a : '';
+        this.idType = (_b = data.idType) !== null && _b !== void 0 ? _b : '';
+        this.details = _extractEvaluationDetails(data.details);
+        this.secondaryExposures =
+            (_c = data.secondaryExposures) !== null && _c !== void 0 ? _c : [];
+    }
+    getEvaluationDetails() {
+        return this.details;
+    }
+    getRuleId() {
+        return this.ruleID;
+    }
+    getIdType() {
+        return this.idType;
+    }
+    getSecondaryExposures() {
+        return this.secondaryExposures;
+    }
+}
+class FeatureGate extends BaseEvaluation {
+    constructor(name, raw) {
+        const data = _parseRawEvaluation(raw);
+        super(name, data);
+        this.value = data.value === true;
+    }
+}
+exports.FeatureGate = FeatureGate;
+class DynamicConfig extends BaseEvaluation {
+    constructor(name, raw) {
+        var _a;
+        const data = _parseRawEvaluation(raw);
+        super(name, data);
+        this.value = {};
+        this.value = (_a = data.value) !== null && _a !== void 0 ? _a : {};
+        this.get = _makeTypedGet(name, this.value);
+        this.getValue = _makeUnknownGet(this.value);
+    }
+}
+exports.DynamicConfig = DynamicConfig;
+class Experiment extends BaseEvaluation {
+    constructor(name, raw) {
+        var _a, _b;
+        const data = _parseRawEvaluation(raw);
+        super(name, data);
+        this.groupName = null;
+        this.value = {};
+        this.groupName = (_a = data.groupName) !== null && _a !== void 0 ? _a : null;
+        this.value = (_b = data.value) !== null && _b !== void 0 ? _b : {};
+        this.get = _makeTypedGet(name, this.value);
+        this.getValue = _makeUnknownGet(this.value);
+    }
+    getGroupName() {
+        return this.groupName;
+    }
+}
+exports.Experiment = Experiment;
+class Layer extends BaseEvaluation {
+    constructor(exposeFn, name, raw) {
+        var _a, _b, _c;
+        const data = _parseRawEvaluation(raw);
+        super(name, data);
+        this.groupName = null;
+        this.allocatedExperimentName = null;
+        this.__value = {};
+        this.__value = (_a = data.value) !== null && _a !== void 0 ? _a : {};
+        this.groupName = (_b = data.groupName) !== null && _b !== void 0 ? _b : null;
+        this.allocatedExperimentName =
+            (_c = data.allocatedExperimentName) !== null && _c !== void 0 ? _c : null;
+        this.get = _makeTypedGet(name, this.__value, exposeFn);
+        this.getValue = _makeUnknownGet(this.__value, exposeFn);
+    }
+    getGroupName() {
+        return this.groupName;
+    }
+    getAllocatedExperimentName() {
+        return this.allocatedExperimentName;
+    }
+}
+exports.Layer = Layer;
+function _parseRawEvaluation(raw) {
+    if (raw == null) {
+        return {};
+    }
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        return raw;
+    }
+    if (typeof raw !== 'string') {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        console.error(`[Statsig] Error parsing BaseEvaluation: ${error}`);
+        return {};
+    }
+}
+function _makeTypedGet(name, value, exposeFunc) {
+    return (key, defaultValue, typeGuard = null) => {
+        var _a;
+        // @ts-ignore - intentionally matches legacy behavior exactly
+        defaultValue = defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+        // Equivalent to legacy `this.getValue(key, defaultValue)`
+        const val = ((_a = value[key]) !== null && _a !== void 0 ? _a : defaultValue);
+        if (val == null) {
+            return defaultValue;
+        }
+        const expectedType = _getTypeOf(defaultValue);
+        const actualType = _getTypeOf(val);
+        if (typeGuard != null) {
+            if (typeGuard(val)) {
+                exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(key);
+                return val;
+            }
+            console.warn(`[Statsig] Parameter type mismatch. '${name}.${key}' failed typeGuard. Expected '${expectedType}', got '${actualType}'`);
+            return defaultValue;
+        }
+        if (defaultValue == null || expectedType === actualType) {
+            exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(key);
+            return val;
+        }
+        console.warn(`[Statsig] Parameter type mismatch. '${name}.${key}' was found to be type '${actualType}' but fallback/return type is '${expectedType}'`);
+        return defaultValue;
+    };
+}
+function _makeUnknownGet(value, exposeFunc) {
+    return (param, fallback) => {
+        var _a;
+        if (fallback === undefined) {
+            fallback = null;
+        }
+        if (param == null) {
+            return fallback;
+        }
+        if (value[param] != null) {
+            exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(param);
+        }
+        return (_a = value[param]) !== null && _a !== void 0 ? _a : fallback;
+    };
+}
+function _extractEvaluationDetails(data) {
+    if (data == null) {
+        return {
+            reason: '',
+            lcut: 0,
+            receivedAt: 0,
+            version: 0,
+        };
+    }
+    return {
+        reason: data.reason,
+        lcut: data.lcut,
+        receivedAt: data.received_at,
+        version: data.version,
+    };
+}