@anterprize/fturex 0.0.1

package/dist/FtureXClient.js

@@ -0,0 +1,427 @@
+/**
+ * FtureX Client
+ * Fetches the full feature manifest in the background and evaluates
+ * conditions locally — no per-call network round-trips.
+ */
+export class FtureXClient {
+    constructor(config, cacheOptions = {}) {
+        // Hooks
+        this.hooks = [];
+        // Manifest replaced atomically on each background refresh (JS is single-threaded)
+        this.manifest = new Map();
+        // Event listeners
+        this.listeners = new Map([
+            ["update", new Set()],
+            ["ready", new Set()],
+        ]);
+        // Statistics tracking
+        this.featureHitCounts = new Map();
+        this.featureEnabledCounts = new Map();
+        this.featureDisabledCounts = new Map();
+        this.featureLastAccessed = new Map();
+        this.config = {
+            baseUrl: config.baseUrl,
+            appKey: config.appKey,
+            sendStatistics: config.sendStatistics ?? true,
+        };
+        this.cacheOptions = {
+            refreshIntervalSeconds: cacheOptions.refreshIntervalSeconds ?? 30,
+            enableLocalStoragePersistence: cacheOptions.enableLocalStoragePersistence ?? true,
+            localStorageKey: cacheOptions.localStorageKey ?? "feature-toggle-cache",
+        };
+    }
+    /**
+     * Subscribe to an event.
+     * - 'ready'  — fires once after the first successful manifest fetch
+     * - 'update' — fires after every subsequent manifest refresh
+     */
+    on(event, callback) {
+        this.listeners.get(event).add(callback);
+    }
+    /** Unsubscribe a previously registered callback. */
+    off(event, callback) {
+        this.listeners.get(event).delete(callback);
+    }
+    emit(event) {
+        this.listeners.get(event).forEach((cb) => cb());
+    }
+    /**
+     * Initialize the client — loads persisted manifest and starts background services
+     */
+    async initialize() {
+        await this.loadManifestFromStorage();
+        await this.refreshManifest(); // initial fetch
+        this.emit("ready");
+        this.startBackgroundRefresh();
+        if (this.config.sendStatistics) {
+            this.startStatisticsReporting();
+        }
+    }
+    /**
+     * Stop all background services
+     */
+    dispose() {
+        if (this.refreshIntervalId)
+            clearInterval(this.refreshIntervalId);
+        if (this.statisticsIntervalId)
+            clearInterval(this.statisticsIntervalId);
+        this.listeners.get("update").clear();
+        this.listeners.get("ready").clear();
+    }
+    /**
+     * Register a hook that will be called for every flag evaluation.
+     */
+    addHook(hook) {
+        this.hooks.push(hook);
+    }
+    /**
+     * Check if a feature is enabled (no context)
+     */
+    async isEnabled(featureName) {
+        return this.isEnabledWithContext(featureName, {});
+    }
+    /**
+     * Check if a feature is enabled with context properties evaluated locally
+     */
+    async isEnabledWithContext(featureName, context) {
+        const hookCtx = {
+            flagKey: featureName,
+            evaluationContext: Object.keys(context).length > 0 ? context : undefined,
+            defaultValue: false,
+        };
+        await this.invokeHooksBefore(hookCtx);
+        const entry = this.manifest.get(featureName.toLowerCase()) ??
+            this.findEntry(featureName);
+        if (!entry) {
+            const defaultResult = {
+                value: false,
+                reason: "default",
+            };
+            await this.invokeHooksAfter(hookCtx, defaultResult);
+            return false;
+        }
+        const result = this.evaluateEntry(entry, context);
+        const reason = this.determineReason(entry, context, result);
+        const evalResult = { value: result, reason };
+        await this.invokeHooksAfter(hookCtx, evalResult);
+        this.trackFeatureHit(featureName, result);
+        return result;
+    }
+    determineReason(entry, context, _result) {
+        if (!entry.enabled)
+            return "disabled";
+        if (!entry.conditions || entry.conditions.length === 0)
+            return "static";
+        return Object.keys(context).length > 0 ? "targeting_match" : "static";
+    }
+    async invokeHooksBefore(context) {
+        for (const hook of this.hooks) {
+            try {
+                await hook.before?.(context);
+            }
+            catch {
+                /* hook errors are swallowed */
+            }
+        }
+    }
+    async invokeHooksAfter(context, result) {
+        for (const hook of this.hooks) {
+            try {
+                await hook.after?.(context, result);
+            }
+            catch {
+                /* hook errors are swallowed */
+            }
+        }
+    }
+    async invokeHooksError(context, error) {
+        for (const hook of this.hooks) {
+            try {
+                await hook.error?.(context, error);
+            }
+            catch {
+                /* hook errors are swallowed */
+            }
+        }
+    }
+    // ─── Local evaluation ───────────────────────────────────────────────────────
+    findEntry(featureName) {
+        for (const [key, value] of this.manifest.entries()) {
+            if (key.toLowerCase() === featureName.toLowerCase())
+                return value;
+        }
+        return undefined;
+    }
+    evaluateEntry(entry, context) {
+        if (!entry.enabled)
+            return false;
+        if (!entry.conditions || entry.conditions.length === 0)
+            return true;
+        return this.evaluateConditions(entry.conditions, context);
+    }
+    evaluateConditions(conditions, context) {
+        if (conditions.length === 0)
+            return true;
+        // Split the flat list into AND-segments at every OR boundary.
+        // AND binds tighter than OR — (A AND B OR C) = (A AND B) OR (C).
+        // The overall expression is true if ANY segment is fully satisfied.
+        const segments = [];
+        let current = [];
+        for (let i = 0; i < conditions.length; i++) {
+            current.push(conditions[i]);
+            const logic = (conditions[i].logicAfter ?? "AND").toUpperCase();
+            if (logic === "OR" || i === conditions.length - 1) {
+                segments.push(current);
+                current = [];
+            }
+        }
+        return segments.some((seg) => this.evaluateAndSegment(seg, context));
+    }
+    /** Returns true only when ALL rules in the segment match. */
+    evaluateAndSegment(rules, context) {
+        for (const rule of rules) {
+            const providedValue = context[rule.contextProperty];
+            if (providedValue === undefined)
+                return false;
+            let match;
+            if (rule.conditionGroupValues && rule.conditionGroupValues.length > 0) {
+                match = this.evaluateValueListCondition(rule.operator, rule.conditionGroupValues, providedValue);
+            }
+            else if (rule.value !== undefined && rule.value !== null) {
+                match = this.evaluateDirectValueCondition(rule.operator, rule.value, providedValue);
+            }
+            else {
+                return false; // invalid rule
+            }
+            if (!match)
+                return false;
+        }
+        return true;
+    }
+    evaluateDirectValueCondition(op, ruleValue, providedValue) {
+        switch (op) {
+            case "Contains": {
+                const ruleValues = ruleValue
+                    .split(",")
+                    .map((v) => v.trim().toLowerCase());
+                return providedValue
+                    .split(",")
+                    .some((v) => ruleValues.includes(v.trim().toLowerCase()));
+            }
+            case "NotContains": {
+                const ruleValues = ruleValue
+                    .split(",")
+                    .map((v) => v.trim().toLowerCase());
+                return !providedValue
+                    .split(",")
+                    .some((v) => ruleValues.includes(v.trim().toLowerCase()));
+            }
+            case "Match":
+                return (this.orderCommaSeparated(ruleValue) ===
+                    this.orderCommaSeparated(providedValue));
+            case "NotMatch":
+                return (this.orderCommaSeparated(ruleValue) !==
+                    this.orderCommaSeparated(providedValue));
+            case "GreaterThan": {
+                const rv = parseInt(ruleValue, 10);
+                const pv = parseInt(providedValue, 10);
+                return !isNaN(rv) && !isNaN(pv) && pv > rv;
+            }
+            case "LessThan": {
+                const rv = parseInt(ruleValue, 10);
+                const pv = parseInt(providedValue, 10);
+                return !isNaN(rv) && !isNaN(pv) && pv < rv;
+            }
+            default:
+                return false;
+        }
+    }
+    evaluateValueListCondition(op, values, providedValue) {
+        const normalised = values.map((v) => v.toLowerCase());
+        switch (op) {
+            case "Contains":
+                return providedValue
+                    .split(",")
+                    .some((v) => normalised.includes(v.trim().toLowerCase()));
+            case "NotContains":
+                return !providedValue
+                    .split(",")
+                    .some((v) => normalised.includes(v.trim().toLowerCase()));
+            case "Match":
+                return ([...values]
+                    .sort((a, b) => a.localeCompare(b))
+                    .join(",")
+                    .toLowerCase() === this.orderCommaSeparated(providedValue));
+            case "NotMatch":
+                return ([...values]
+                    .sort((a, b) => a.localeCompare(b))
+                    .join(",")
+                    .toLowerCase() !== this.orderCommaSeparated(providedValue));
+            default:
+                return false;
+        }
+    }
+    orderCommaSeparated(value) {
+        return value
+            .split(",")
+            .map((v) => v.trim().toLowerCase())
+            .sort()
+            .join(",");
+    }
+    // ─── Manifest management ────────────────────────────────────────────────────
+    async refreshManifest() {
+        try {
+            const manifest = await this.fetchManifestFromApi();
+            // Atomic swap — replace entire map reference
+            const newMap = new Map();
+            for (const entry of manifest.features) {
+                newMap.set(entry.name.toLowerCase(), entry);
+            }
+            this.manifest = newMap;
+            if (this.cacheOptions.enableLocalStoragePersistence) {
+                this.saveManifestToStorage(manifest);
+            }
+            this.emit("update");
+        }
+        catch (error) {
+            console.error("Failed to refresh feature manifest:", error);
+        }
+    }
+    async fetchManifestFromApi() {
+        const url = `${this.config.baseUrl}/feature/manifest`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "X-API-Key": this.config.appKey,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Manifest fetch returned ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    // ─── Background services ────────────────────────────────────────────────────
+    startBackgroundRefresh() {
+        const intervalMs = this.cacheOptions.refreshIntervalSeconds * 1000;
+        this.refreshIntervalId = setInterval(async () => {
+            await this.refreshManifest();
+        }, intervalMs);
+    }
+    startStatisticsReporting() {
+        // Report statistics at the same interval as manifest refresh
+        const intervalMs = this.cacheOptions.refreshIntervalSeconds * 1000;
+        this.statisticsIntervalId = setInterval(async () => {
+            await this.sendStatistics();
+        }, intervalMs);
+    }
+    // ─── Statistics ─────────────────────────────────────────────────────────────
+    trackFeatureHit(featureName, wasEnabled) {
+        if (!this.config.sendStatistics)
+            return;
+        this.featureHitCounts.set(featureName, (this.featureHitCounts.get(featureName) || 0) + 1);
+        if (wasEnabled) {
+            this.featureEnabledCounts.set(featureName, (this.featureEnabledCounts.get(featureName) || 0) + 1);
+        }
+        else {
+            this.featureDisabledCounts.set(featureName, (this.featureDisabledCounts.get(featureName) || 0) + 1);
+        }
+        this.featureLastAccessed.set(featureName, new Date());
+    }
+    async sendStatistics() {
+        if (!this.config.sendStatistics)
+            return;
+        if (this.featureHitCounts.size === 0)
+            return;
+        try {
+            const features = [];
+            for (const [featureName, hitCount] of this.featureHitCounts.entries()) {
+                features.push({
+                    featureName,
+                    hitCount,
+                    enabledCount: this.featureEnabledCounts.get(featureName) || 0,
+                    disabledCount: this.featureDisabledCounts.get(featureName) || 0,
+                    lastAccessed: this.featureLastAccessed.get(featureName) || new Date(),
+                });
+            }
+            const report = {
+                appKey: this.config.appKey,
+                features,
+                reportTimestamp: new Date(),
+            };
+            const response = await fetch(`${this.config.baseUrl}/api/Statistics/Report`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "X-API-Key": this.config.appKey,
+                },
+                body: JSON.stringify(report),
+            });
+            if (response.ok) {
+                this.resetStatistics();
+            }
+            else {
+                console.warn(`Failed to send statistics: ${response.status}`);
+            }
+        }
+        catch (error) {
+            console.error("Error sending statistics:", error);
+        }
+    }
+    resetStatistics() {
+        this.featureHitCounts.clear();
+        this.featureEnabledCounts.clear();
+        this.featureDisabledCounts.clear();
+        this.featureLastAccessed.clear();
+    }
+    getStatistics() {
+        const stats = [];
+        for (const [featureName, hitCount] of this.featureHitCounts.entries()) {
+            stats.push({
+                featureName,
+                hitCount,
+                enabledCount: this.featureEnabledCounts.get(featureName) || 0,
+                disabledCount: this.featureDisabledCounts.get(featureName) || 0,
+                lastAccessed: this.featureLastAccessed.get(featureName) || new Date(),
+            });
+        }
+        return stats;
+    }
+    // ─── LocalStorage persistence ───────────────────────────────────────────────
+    saveManifestToStorage(manifest) {
+        if (typeof window === "undefined" || !window.localStorage)
+            return;
+        try {
+            localStorage.setItem(this.cacheOptions.localStorageKey, JSON.stringify(manifest));
+        }
+        catch (error) {
+            console.error("Failed to persist manifest to localStorage:", error);
+        }
+    }
+    async loadManifestFromStorage() {
+        if (typeof window === "undefined" || !window.localStorage)
+            return;
+        try {
+            const stored = localStorage.getItem(this.cacheOptions.localStorageKey);
+            if (!stored)
+                return;
+            const manifest = JSON.parse(stored);
+            if (!manifest?.features?.length)
+                return;
+            const newMap = new Map();
+            for (const entry of manifest.features) {
+                newMap.set(entry.name.toLowerCase(), entry);
+            }
+            this.manifest = newMap;
+        }
+        catch (error) {
+            console.error("Failed to load manifest from localStorage:", error);
+        }
+    }
+    clearCache() {
+        this.manifest.clear();
+        if (typeof window !== "undefined" && window.localStorage) {
+            localStorage.removeItem(this.cacheOptions.localStorageKey);
+        }
+    }
+}

package/dist/angular/feature-toggle.directive.d.ts

@@ -0,0 +1,32 @@
+import { OnInit, OnDestroy, TemplateRef, ViewContainerRef } from '@angular/core';
+import { FtureXService } from './fturex.service.js';
+import { ContextProperties } from '../types.js';
+/**
+ * Structural directive that conditionally renders a template based on a feature toggle.
+ *
+ * @example
+ * <!-- Simple usage -->
+ * <div *ftureX="'new-dashboard'">New dashboard content</div>
+ *
+ * <!-- With else template -->
+ * <div *ftureX="'new-dashboard'; else legacyTpl">New content</div>
+ * <ng-template #legacyTpl>Legacy content</ng-template>
+ *
+ * <!-- With context and fallback -->
+ * <div *ftureX="'beta-feature'; context: { role: 'admin' }; fallback: false">
+ *   Beta content
+ * </div>
+ */
+export declare class FeatureToggleDirective implements OnInit, OnDestroy {
+    private readonly templateRef;
+    private readonly viewContainer;
+    private readonly ftureXService;
+    featureName: string;
+    context?: ContextProperties;
+    elseTemplate?: TemplateRef<unknown>;
+    private subscription?;
+    private hasView;
+    constructor(templateRef: TemplateRef<unknown>, viewContainer: ViewContainerRef, ftureXService: FtureXService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+}

package/dist/angular/feature-toggle.directive.js

@@ -0,0 +1,77 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { FtureXService } from './fturex.service.js';
+/**
+ * Structural directive that conditionally renders a template based on a feature toggle.
+ *
+ * @example
+ * <!-- Simple usage -->
+ * <div *ftureX="'new-dashboard'">New dashboard content</div>
+ *
+ * <!-- With else template -->
+ * <div *ftureX="'new-dashboard'; else legacyTpl">New content</div>
+ * <ng-template #legacyTpl>Legacy content</ng-template>
+ *
+ * <!-- With context and fallback -->
+ * <div *ftureX="'beta-feature'; context: { role: 'admin' }; fallback: false">
+ *   Beta content
+ * </div>
+ */
+let FeatureToggleDirective = class FeatureToggleDirective {
+    constructor(templateRef, viewContainer, ftureXService) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.ftureXService = ftureXService;
+        this.featureName = '';
+        this.hasView = false;
+    }
+    ngOnInit() {
+        const obs$ = this.context
+            ? this.ftureXService.isEnabledWithContext(this.featureName, this.context)
+            : this.ftureXService.isEnabled(this.featureName);
+        this.subscription = obs$.subscribe((isEnabled) => {
+            if (isEnabled && !this.hasView) {
+                this.viewContainer.clear();
+                this.viewContainer.createEmbeddedView(this.templateRef);
+                this.hasView = true;
+            }
+            else if (!isEnabled) {
+                this.viewContainer.clear();
+                this.hasView = false;
+                if (this.elseTemplate) {
+                    this.viewContainer.createEmbeddedView(this.elseTemplate);
+                }
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.subscription?.unsubscribe();
+    }
+};
+__decorate([
+    Input('ftureX'),
+    __metadata("design:type", Object)
+], FeatureToggleDirective.prototype, "featureName", void 0);
+__decorate([
+    Input('ftureXContext'),
+    __metadata("design:type", Object)
+], FeatureToggleDirective.prototype, "context", void 0);
+__decorate([
+    Input('ftureXElse'),
+    __metadata("design:type", TemplateRef)
+], FeatureToggleDirective.prototype, "elseTemplate", void 0);
+FeatureToggleDirective = __decorate([
+    Directive({ selector: '[ftureX]' }),
+    __metadata("design:paramtypes", [TemplateRef,
+        ViewContainerRef,
+        FtureXService])
+], FeatureToggleDirective);
+export { FeatureToggleDirective };

package/dist/angular/feature-toggle.pipe.d.ts

@@ -0,0 +1,20 @@
+import { PipeTransform } from '@angular/core';
+import { Observable } from 'rxjs';
+import { FtureXService } from './fturex.service.js';
+import { ContextProperties } from '../types.js';
+/**
+ * Async pipe that resolves to a boolean indicating whether a feature is enabled.
+ * Must be used with the async pipe in templates.
+ *
+ * @example
+ * <!-- In template -->
+ * <div *ngIf="'new-dashboard' | ftureX | async">New dashboard</div>
+ *
+ * <!-- With context -->
+ * <div *ngIf="'beta-feature' | ftureX: { role: 'admin' } | async">Beta</div>
+ */
+export declare class FeatureTogglePipe implements PipeTransform {
+    private readonly ftureXService;
+    constructor(ftureXService: FtureXService);
+    transform(featureName: string, context?: ContextProperties): Observable<boolean>;
+}

package/dist/angular/feature-toggle.pipe.js

@@ -0,0 +1,37 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Pipe } from '@angular/core';
+import { FtureXService } from './fturex.service.js';
+/**
+ * Async pipe that resolves to a boolean indicating whether a feature is enabled.
+ * Must be used with the async pipe in templates.
+ *
+ * @example
+ * <!-- In template -->
+ * <div *ngIf="'new-dashboard' | ftureX | async">New dashboard</div>
+ *
+ * <!-- With context -->
+ * <div *ngIf="'beta-feature' | ftureX: { role: 'admin' } | async">Beta</div>
+ */
+let FeatureTogglePipe = class FeatureTogglePipe {
+    constructor(ftureXService) {
+        this.ftureXService = ftureXService;
+    }
+    transform(featureName, context) {
+        return context
+            ? this.ftureXService.isEnabledWithContext(featureName, context)
+            : this.ftureXService.isEnabled(featureName);
+    }
+};
+FeatureTogglePipe = __decorate([
+    Pipe({ name: 'ftureX', pure: true }),
+    __metadata("design:paramtypes", [FtureXService])
+], FeatureTogglePipe);
+export { FeatureTogglePipe };

package/dist/angular/fturex.config.d.ts

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { FtureXConfiguration, FeatureCacheOptions } from '../types.js';
+export interface FtureXModuleConfig {
+    config: FtureXConfiguration;
+    cacheOptions?: FeatureCacheOptions;
+}
+export declare const FTUREX_CONFIG: InjectionToken<FtureXModuleConfig>;

package/dist/angular/fturex.config.js

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export const FTUREX_CONFIG = new InjectionToken('FTUREX_CONFIG');

package/dist/angular/fturex.module.d.ts

@@ -0,0 +1,23 @@
+import { ModuleWithProviders } from '@angular/core';
+import { FtureXModuleConfig } from './fturex.config.js';
+/**
+ * Angular module for FtureX feature toggles.
+ *
+ * @example
+ * // app.module.ts
+ * @NgModule({
+ *   imports: [
+ *     FtureXModule.forRoot({
+ *       config: {
+ *         baseUrl: 'https://api.example.com',
+ *         appKey: 'your-api-key',
+ *       },
+ *       cacheOptions: { refreshIntervalSeconds: 60 },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ */
+export declare class FtureXModule {
+    static forRoot(moduleConfig: FtureXModuleConfig): ModuleWithProviders<FtureXModule>;
+}

package/dist/angular/fturex.module.js

@@ -0,0 +1,48 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var FtureXModule_1;
+import { NgModule } from '@angular/core';
+import { FtureXService } from './fturex.service.js';
+import { FeatureToggleDirective } from './feature-toggle.directive.js';
+import { FeatureTogglePipe } from './feature-toggle.pipe.js';
+import { FTUREX_CONFIG } from './fturex.config.js';
+/**
+ * Angular module for FtureX feature toggles.
+ *
+ * @example
+ * // app.module.ts
+ * @NgModule({
+ *   imports: [
+ *     FtureXModule.forRoot({
+ *       config: {
+ *         baseUrl: 'https://api.example.com',
+ *         appKey: 'your-api-key',
+ *       },
+ *       cacheOptions: { refreshIntervalSeconds: 60 },
+ *     }),
+ *   ],
+ * })
+ * export class AppModule {}
+ */
+let FtureXModule = FtureXModule_1 = class FtureXModule {
+    static forRoot(moduleConfig) {
+        return {
+            ngModule: FtureXModule_1,
+            providers: [
+                { provide: FTUREX_CONFIG, useValue: moduleConfig },
+                FtureXService,
+            ],
+        };
+    }
+};
+FtureXModule = FtureXModule_1 = __decorate([
+    NgModule({
+        declarations: [FeatureToggleDirective, FeatureTogglePipe],
+        exports: [FeatureToggleDirective, FeatureTogglePipe],
+    })
+], FtureXModule);
+export { FtureXModule };