featurehub-javascript-client-sdk/lib/local_context.js

FeatureHub client/browser SDK

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { BaseClientContext } from './context_impl';
import { Readyness } from './featurehub_repository';
import { FeatureStateBaseHolder } from './feature_state_holders';
import { FeatureValueType } from './models';
import { ApplyFeature } from './strategy_matcher';
class LocalFeatureRepository {
    constructor(environment, applyFeature) {
        var _a;
        this.features = new Map();
        this.analyticsCollectors = new Array();
        this._matchers = [];
        this._applyFeature = applyFeature || new ApplyFeature();
        (_a = environment.features) === null || _a === void 0 ? void 0 : _a.forEach((fs) => {
            const holder = new FeatureStateBaseHolder(this, fs.key);
            holder.setFeatureState(fs);
            this.features.set(fs.key, holder);
        });
    }
    apply(strategies, key, featureValueId, context) {
        return this._applyFeature.apply(strategies, key, featureValueId, context);
    }
    get readyness() {
        return Readyness.Ready;
    }
    notify(state, data) { }
    addValueInterceptor(matcher) {
        this._matchers.push(matcher);
        matcher.repository(this);
    }
    valueInterceptorMatched(key) {
        for (const matcher of this._matchers) {
            const m = matcher.matched(key);
            if (m === null || m === void 0 ? void 0 : m.value) {
                return m;
            }
        }
        return undefined;
    }
    addPostLoadNewFeatureStateAvailableListener(_) {
        return 0;
    }
    removePostLoadNewFeatureStateAvailableListener(_) {
    }
    addReadynessListener(listener) {
        return this.addReadinessListener(listener);
    }
    addReadinessListener(listener, _) {
        listener(Readyness.Ready, true);
        return 0;
    }
    removeReadinessListener(_) {
    }
    notReady() {
    }
    broadcastReadynessState() {
        return __awaiter(this, void 0, void 0, function* () {
        });
    }
    addAnalyticCollector(collector) {
        this.analyticsCollectors.push(collector);
    }
    simpleFeatures() {
        const vals = new Map();
        this.features.forEach((value, key) => {
            if (value.getKey()) {
                let val;
                switch (value.getType()) {
                    case FeatureValueType.Boolean:
                        val = value.getBoolean() ? 'true' : 'false';
                        break;
                    case FeatureValueType.String:
                        val = value.getString();
                        break;
                    case FeatureValueType.Number:
                        val = value.getNumber();
                        break;
                    case FeatureValueType.Json:
                        val = value.getRawJson();
                        break;
                    default:
                        val = undefined;
                }
                vals.set(key, val === undefined ? val : val.toString());
            }
        });
        return vals;
    }
    logAnalyticsEvent(action, other, ctx) {
        const featureStateAtCurrentTime = [];
        for (const fs of this.features.values()) {
            if (fs.isSet()) {
                const fsVal = ctx == null ? fs : fs.withContext(ctx);
                featureStateAtCurrentTime.push(fsVal.analyticsCopy());
            }
        }
        this.analyticsCollectors.forEach((ac) => ac.logEvent(action, other || new Map(), featureStateAtCurrentTime));
    }
    hasFeature(key) {
        return this.features.get(key);
    }
    feature(key) {
        let holder = this.features.get(key);
        if (holder === undefined) {
            holder = new FeatureStateBaseHolder(this, key);
            this.features.set(key, holder);
        }
        return holder;
    }
    getFeatureState(key) {
        return this.feature(key);
    }
    get catchAndReleaseMode() {
        return false;
    }
    set catchAndReleaseMode(value) { }
    release(disableCatchAndRelease) {
        return __awaiter(this, void 0, void 0, function* () { });
    }
    getFlag(key) {
        return this.feature(key).getFlag();
    }
    getString(key) {
        return this.feature(key).getString();
    }
    getJson(key) {
        return this.feature(key).getRawJson();
    }
    getNumber(key) {
        return this.feature(key).getNumber();
    }
    isSet(key) {
        return this.feature(key).isSet();
    }
}
export class LocalClientContext extends BaseClientContext {
    constructor(environment) {
        super(new LocalFeatureRepository(environment));
    }
    build() {
        return __awaiter(this, void 0, void 0, function* () {
            return this;
        });
    }
    feature(name) {
        return this._repository.feature(name).withContext(this);
    }
    close() { }
}
//# sourceMappingURL=local_context.js.map