@anterprize/fturex 0.0.1

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

@@ -0,0 +1,31 @@
+import { OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ContextProperties } from '../types.js';
+import { FtureXModuleConfig } from './fturex.config.js';
+/**
+ * Angular injectable service wrapping FtureXClient.
+ * Provide via FtureXModule.forRoot() in your AppModule.
+ *
+ * @example
+ * constructor(private ftureX: FtureXService) {}
+ *
+ * ngOnInit() {
+ *   this.ftureX.isEnabled('new-dashboard').subscribe(enabled => {
+ *     this.showNewDashboard = enabled;
+ *   });
+ * }
+ */
+export declare class FtureXService implements OnDestroy {
+    private readonly client;
+    readonly initialized: Promise<void>;
+    constructor(moduleConfig: FtureXModuleConfig);
+    /**
+     * Check if a feature is enabled (no context)
+     */
+    isEnabled(featureName: string): Observable<boolean>;
+    /**
+     * Check if a feature is enabled with context properties
+     */
+    isEnabledWithContext(featureName: string, context: ContextProperties): Observable<boolean>;
+    ngOnDestroy(): void;
+}

package/dist/angular/fturex.service.js

@@ -0,0 +1,56 @@
+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);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable, Inject } from '@angular/core';
+import { from } from 'rxjs';
+import { FtureXClient } from '../FtureXClient.js';
+import { FTUREX_CONFIG } from './fturex.config.js';
+/**
+ * Angular injectable service wrapping FtureXClient.
+ * Provide via FtureXModule.forRoot() in your AppModule.
+ *
+ * @example
+ * constructor(private ftureX: FtureXService) {}
+ *
+ * ngOnInit() {
+ *   this.ftureX.isEnabled('new-dashboard').subscribe(enabled => {
+ *     this.showNewDashboard = enabled;
+ *   });
+ * }
+ */
+let FtureXService = class FtureXService {
+    constructor(moduleConfig) {
+        this.client = new FtureXClient(moduleConfig.config, moduleConfig.cacheOptions);
+        this.initialized = this.client.initialize();
+    }
+    /**
+     * Check if a feature is enabled (no context)
+     */
+    isEnabled(featureName) {
+        return from(this.client.isEnabled(featureName));
+    }
+    /**
+     * Check if a feature is enabled with context properties
+     */
+    isEnabledWithContext(featureName, context) {
+        return from(this.client.isEnabledWithContext(featureName, context));
+    }
+    ngOnDestroy() {
+        this.client.dispose();
+    }
+};
+FtureXService = __decorate([
+    Injectable(),
+    __param(0, Inject(FTUREX_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], FtureXService);
+export { FtureXService };

package/dist/angular/index.d.ts

@@ -0,0 +1,6 @@
+export { FtureXModule } from './fturex.module.js';
+export { FtureXService } from './fturex.service.js';
+export { FeatureToggleDirective } from './feature-toggle.directive.js';
+export { FeatureTogglePipe } from './feature-toggle.pipe.js';
+export { FTUREX_CONFIG } from './fturex.config.js';
+export type { FtureXModuleConfig } from './fturex.config.js';

package/dist/angular/index.js

@@ -0,0 +1,5 @@
+export { FtureXModule } from './fturex.module.js';
+export { FtureXService } from './fturex.service.js';
+export { FeatureToggleDirective } from './feature-toggle.directive.js';
+export { FeatureTogglePipe } from './feature-toggle.pipe.js';
+export { FTUREX_CONFIG } from './fturex.config.js';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { FtureXClient } from './FtureXClient.js';
+export type { FtureXConfiguration, FeatureCacheOptions, ContextProperties, FeatureStatistics, StatisticsReport, FtureXHook, HookContext, EvaluationResult, EvaluationReason } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+// Core client
+export { FtureXClient } from './FtureXClient.js';

package/dist/opentelemetry/FtureXOtelHook.d.ts

@@ -0,0 +1,58 @@
+import type { FtureXHook, HookContext, EvaluationResult } from '../types.js';
+/**
+ * Options for the FtureX OpenTelemetry hook.
+ */
+export interface FtureXOtelOptions {
+    /** Add span events to the current active span on each evaluation. Default: true */
+    addSpanEvents?: boolean;
+    /** Emit evaluation counters as OTel metrics. Default: true */
+    addMetrics?: boolean;
+    /** Include the evaluated flag value in span event attributes. Default: false */
+    recordFlagValue?: boolean;
+    /** Optional identifier for the feature flag set (e.g. environment name). */
+    setId?: string;
+}
+/**
+ * Minimal OTel API surface used by this hook.
+ * Compatible with `@opentelemetry/api` — pass the module directly.
+ */
+export interface OtelApi {
+    trace: {
+        getActiveSpan(): {
+            addEvent(name: string, attributes?: Record<string, string>): void;
+        } | undefined;
+    };
+    metrics: {
+        getMeter(name: string): {
+            createCounter(name: string, options?: {
+                description?: string;
+            }): {
+                add(value: number, attributes?: Record<string, string>): void;
+            };
+        };
+    };
+}
+/**
+ * OpenTelemetry hook for FtureX.
+ * Emits span events and metrics following OTel semantic conventions for feature flags.
+ *
+ * Requires `@opentelemetry/api` as a peer dependency.
+ *
+ * @example
+ * ```ts
+ * import { FtureXOtelHook } from 'fturex/opentelemetry';
+ * import * as api from '@opentelemetry/api';
+ *
+ * const otelHook = new FtureXOtelHook(api, { recordFlagValue: true });
+ * client.addHook(otelHook);
+ * ```
+ */
+export declare class FtureXOtelHook implements FtureXHook {
+    private readonly options;
+    private readonly otel;
+    private evalSuccessCounter?;
+    private evalErrorCounter?;
+    constructor(otel: OtelApi, options?: FtureXOtelOptions);
+    after(context: HookContext, result: EvaluationResult): void;
+    error(context: HookContext, error: unknown): void;
+}

package/dist/opentelemetry/FtureXOtelHook.js

@@ -0,0 +1,86 @@
+/**
+ * OpenTelemetry hook for FtureX.
+ * Emits span events and metrics following OTel semantic conventions for feature flags.
+ *
+ * Requires `@opentelemetry/api` as a peer dependency.
+ *
+ * @example
+ * ```ts
+ * import { FtureXOtelHook } from 'fturex/opentelemetry';
+ * import * as api from '@opentelemetry/api';
+ *
+ * const otelHook = new FtureXOtelHook(api, { recordFlagValue: true });
+ * client.addHook(otelHook);
+ * ```
+ */
+export class FtureXOtelHook {
+    constructor(otel, options = {}) {
+        this.otel = otel;
+        this.options = {
+            addSpanEvents: options.addSpanEvents ?? true,
+            addMetrics: options.addMetrics ?? true,
+            recordFlagValue: options.recordFlagValue ?? false,
+            setId: options.setId ?? '',
+        };
+        if (this.options.addMetrics) {
+            const meter = otel.metrics.getMeter('fturex');
+            this.evalSuccessCounter = meter.createCounter('feature_flag.evaluation_success_total', {
+                description: 'Number of successful feature flag evaluations',
+            });
+            this.evalErrorCounter = meter.createCounter('feature_flag.evaluation_error_total', {
+                description: 'Number of failed feature flag evaluations',
+            });
+        }
+    }
+    after(context, result) {
+        if (this.options.addSpanEvents) {
+            const span = this.otel.trace.getActiveSpan();
+            if (span) {
+                const attributes = {
+                    'feature_flag.key': context.flagKey,
+                    'feature_flag.provider.name': 'FtureX',
+                    'feature_flag.result.reason': result.reason,
+                };
+                if (this.options.recordFlagValue) {
+                    attributes['feature_flag.result.value'] = String(result.value);
+                }
+                if (this.options.setId) {
+                    attributes['feature_flag.set.id'] = this.options.setId;
+                }
+                if (context.evaluationContext) {
+                    const contextId = context.evaluationContext['userId'] ?? context.evaluationContext['tenantId'];
+                    if (contextId) {
+                        attributes['feature_flag.context.id'] = contextId;
+                    }
+                }
+                span.addEvent('feature_flag.evaluation', attributes);
+            }
+        }
+        if (this.options.addMetrics && this.evalSuccessCounter) {
+            this.evalSuccessCounter.add(1, {
+                'feature_flag.key': context.flagKey,
+                'feature_flag.provider.name': 'FtureX',
+            });
+        }
+    }
+    error(context, error) {
+        if (this.options.addSpanEvents) {
+            const span = this.otel.trace.getActiveSpan();
+            if (span) {
+                span.addEvent('feature_flag.evaluation', {
+                    'feature_flag.key': context.flagKey,
+                    'feature_flag.provider.name': 'FtureX',
+                    'feature_flag.result.reason': 'error',
+                    'error.type': error instanceof Error ? error.constructor.name : 'Error',
+                });
+            }
+        }
+        if (this.options.addMetrics && this.evalErrorCounter) {
+            this.evalErrorCounter.add(1, {
+                'feature_flag.key': context.flagKey,
+                'feature_flag.provider.name': 'FtureX',
+                'error.type': error instanceof Error ? error.constructor.name : 'Error',
+            });
+        }
+    }
+}

package/dist/opentelemetry/index.d.ts

@@ -0,0 +1,2 @@
+export { FtureXOtelHook } from './FtureXOtelHook.js';
+export type { FtureXOtelOptions } from './FtureXOtelHook.js';

package/dist/opentelemetry/index.js

@@ -0,0 +1 @@
+export { FtureXOtelHook } from './FtureXOtelHook.js';

package/dist/react/FeatureToggle.d.ts

@@ -0,0 +1,14 @@
+import React, { ReactNode } from "react";
+import { ContextProperties } from "../types.js";
+interface FeatureToggleProps {
+    featureName: string;
+    context?: ContextProperties;
+    children: ReactNode;
+    fallback?: ReactNode;
+    loading?: ReactNode;
+}
+/**
+ * React component for conditional rendering based on feature toggles
+ */
+export declare const FeatureToggle: React.FC<FeatureToggleProps>;
+export {};

package/dist/react/FeatureToggle.js

@@ -0,0 +1,16 @@
+import React from "react";
+import { useFeatureToggle } from "./useFeatureToggle.js";
+/**
+ * React component for conditional rendering based on feature toggles
+ */
+export const FeatureToggle = ({ featureName, context, children, fallback = null, loading: loadingComponent = null, }) => {
+    const { isEnabled, loading, error } = useFeatureToggle(featureName, context);
+    if (loading) {
+        return React.createElement(React.Fragment, null, loadingComponent);
+    }
+    if (error) {
+        console.error(`Error checking feature '${featureName}':`, error);
+        return React.createElement(React.Fragment, null, fallback);
+    }
+    return React.createElement(React.Fragment, null, isEnabled ? children : fallback);
+};

package/dist/react/FeatureToggleProvider.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from 'react';
+import { FtureXClient } from '../FtureXClient.js';
+import { FtureXConfiguration, FeatureCacheOptions } from '../types.js';
+export declare const FeatureToggleContext: React.Context<FtureXClient | null>;
+interface FeatureToggleProviderProps {
+    config: FtureXConfiguration;
+    cacheOptions?: FeatureCacheOptions;
+    children: ReactNode;
+}
+/**
+ * React Provider for Feature Toggle Client
+ * Wrap your app with this provider to enable feature toggle hooks
+ */
+export declare const FeatureToggleProvider: React.FC<FeatureToggleProviderProps>;
+export {};

package/dist/react/FeatureToggleProvider.js

@@ -0,0 +1,17 @@
+import React, { createContext, useEffect, useState } from 'react';
+import { FtureXClient } from '../FtureXClient.js';
+export const FeatureToggleContext = createContext(null);
+/**
+ * React Provider for Feature Toggle Client
+ * Wrap your app with this provider to enable feature toggle hooks
+ */
+export const FeatureToggleProvider = ({ config, cacheOptions, children }) => {
+    const [client] = useState(() => new FtureXClient(config, cacheOptions));
+    useEffect(() => {
+        client.initialize();
+        return () => {
+            client.dispose();
+        };
+    }, [client]);
+    return (React.createElement(FeatureToggleContext.Provider, { value: client }, children));
+};

package/dist/react/index.d.ts

@@ -0,0 +1,3 @@
+export { FeatureToggleProvider, FeatureToggleContext } from './FeatureToggleProvider.js';
+export { useFeatureToggle, useFeatureToggles } from './useFeatureToggle.js';
+export { FeatureToggle } from './FeatureToggle.js';

package/dist/react/index.js

@@ -0,0 +1,3 @@
+export { FeatureToggleProvider, FeatureToggleContext } from './FeatureToggleProvider.js';
+export { useFeatureToggle, useFeatureToggles } from './useFeatureToggle.js';
+export { FeatureToggle } from './FeatureToggle.js';

package/dist/react/useFeatureToggle.d.ts

@@ -0,0 +1,27 @@
+import { ContextProperties } from '../types.js';
+/**
+ * React hook for checking feature toggles.
+ * Re-evaluates automatically whenever the client refreshes its manifest,
+ * so the UI updates without a page reload.
+ *
+ * @param featureName - Name of the feature to check
+ * @param context - Optional context properties for the feature check
+ * @returns Object with isEnabled state, loading state, and error
+ */
+export declare function useFeatureToggle(featureName: string, context?: ContextProperties): {
+    isEnabled: boolean;
+    loading: boolean;
+    error: Error | null;
+};
+/**
+ * React hook for checking multiple feature toggles at once.
+ * Re-evaluates automatically whenever the client refreshes its manifest.
+ *
+ * @param featureNames - Array of feature names to check
+ * @returns Object with features map, loading state, and error
+ */
+export declare function useFeatureToggles(featureNames: string[]): {
+    features: Record<string, boolean>;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/react/useFeatureToggle.js

@@ -0,0 +1,104 @@
+import { useState, useEffect, useContext } from 'react';
+import { FeatureToggleContext } from './FeatureToggleProvider.js';
+/**
+ * React hook for checking feature toggles.
+ * Re-evaluates automatically whenever the client refreshes its manifest,
+ * so the UI updates without a page reload.
+ *
+ * @param featureName - Name of the feature to check
+ * @param context - Optional context properties for the feature check
+ * @returns Object with isEnabled state, loading state, and error
+ */
+export function useFeatureToggle(featureName, context) {
+    const client = useContext(FeatureToggleContext);
+    const [isEnabled, setIsEnabled] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!client) {
+            setError(new Error('FeatureToggleClient not provided. Wrap your app with FeatureToggleProvider.'));
+            setLoading(false);
+            return;
+        }
+        let mounted = true;
+        const evaluate = async () => {
+            try {
+                const enabled = context
+                    ? await client.isEnabledWithContext(featureName, context)
+                    : await client.isEnabled(featureName);
+                if (mounted) {
+                    setIsEnabled(enabled);
+                    setError(null);
+                    setLoading(false);
+                }
+            }
+            catch (err) {
+                if (mounted) {
+                    setError(err);
+                    setIsEnabled(false);
+                    setLoading(false);
+                }
+            }
+        };
+        // Subscribe to manifest updates — re-evaluate whenever the client fetches new data
+        client.on('update', evaluate);
+        client.on('ready', evaluate);
+        // Also evaluate immediately in case the manifest is already loaded
+        evaluate();
+        return () => {
+            mounted = false;
+            client.off('update', evaluate);
+            client.off('ready', evaluate);
+        };
+    }, [client, featureName, JSON.stringify(context)]);
+    return { isEnabled, loading, error };
+}
+/**
+ * React hook for checking multiple feature toggles at once.
+ * Re-evaluates automatically whenever the client refreshes its manifest.
+ *
+ * @param featureNames - Array of feature names to check
+ * @returns Object with features map, loading state, and error
+ */
+export function useFeatureToggles(featureNames) {
+    const client = useContext(FeatureToggleContext);
+    const [features, setFeatures] = useState({});
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        if (!client) {
+            setError(new Error('FeatureToggleClient not provided. Wrap your app with FeatureToggleProvider.'));
+            setLoading(false);
+            return;
+        }
+        let mounted = true;
+        const evaluate = async () => {
+            try {
+                const results = {};
+                await Promise.all(featureNames.map(async (name) => {
+                    results[name] = await client.isEnabled(name);
+                }));
+                if (mounted) {
+                    setFeatures(results);
+                    setError(null);
+                    setLoading(false);
+                }
+            }
+            catch (err) {
+                if (mounted) {
+                    setError(err);
+                    setLoading(false);
+                }
+            }
+        };
+        client.on('update', evaluate);
+        client.on('ready', evaluate);
+        evaluate();
+        return () => {
+            mounted = false;
+            client.off('update', evaluate);
+            client.off('ready', evaluate);
+        };
+    }, [client, JSON.stringify(featureNames)]);
+    return { features, loading, error };
+}

package/dist/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export { useFeatureToggle, useFeatureToggles } from './useFeatureToggle.js';
+export type { FeatureToggleState, FeatureTogglesState } from './useFeatureToggle.js';

package/dist/svelte/index.js

@@ -0,0 +1 @@
+export { useFeatureToggle, useFeatureToggles } from './useFeatureToggle.js';

package/dist/svelte/useFeatureToggle.d.ts

@@ -0,0 +1,54 @@
+import { type Readable } from 'svelte/store';
+import { FtureXClient } from '../FtureXClient.js';
+import { ContextProperties } from '../types.js';
+export interface FeatureToggleState {
+    isEnabled: boolean;
+    loading: boolean;
+    error: Error | null;
+}
+export interface FeatureTogglesState {
+    features: Record<string, boolean>;
+    loading: boolean;
+    error: Error | null;
+}
+/**
+ * Creates a Svelte readable store that resolves to a feature toggle state.
+ * Re-evaluates automatically whenever the client refreshes its manifest,
+ * so the UI updates without a page reload.
+ *
+ * @example
+ * <script>
+ *   import { useFeatureToggle } from 'fturex/svelte';
+ *   import { client } from './fturex';
+ *
+ *   const feature = useFeatureToggle(client, 'new-dashboard');
+ * </script>
+ *
+ * {#if $feature.loading}
+ *   <Spinner />
+ * {:else if $feature.isEnabled}
+ *   <NewDashboard />
+ * {:else}
+ *   <LegacyDashboard />
+ * {/if}
+ */
+export declare function useFeatureToggle(client: FtureXClient, featureName: string, context?: ContextProperties): Readable<FeatureToggleState>;
+/**
+ * Creates a Svelte readable store that resolves to a map of feature toggle states.
+ * Re-evaluates automatically whenever the client refreshes its manifest.
+ *
+ * @example
+ * <script>
+ *   import { useFeatureToggles } from 'fturex/svelte';
+ *   import { client } from './fturex';
+ *
+ *   const features = useFeatureToggles(client, ['feature-a', 'feature-b']);
+ * </script>
+ *
+ * {#if !$features.loading}
+ *   {#if $features.features['feature-a']}
+ *     <FeatureA />
+ *   {/if}
+ * {/if}
+ */
+export declare function useFeatureToggles(client: FtureXClient, featureNames: string[]): Readable<FeatureTogglesState>;

package/dist/svelte/useFeatureToggle.js

@@ -0,0 +1,85 @@
+import { readable } from 'svelte/store';
+/**
+ * Creates a Svelte readable store that resolves to a feature toggle state.
+ * Re-evaluates automatically whenever the client refreshes its manifest,
+ * so the UI updates without a page reload.
+ *
+ * @example
+ * <script>
+ *   import { useFeatureToggle } from 'fturex/svelte';
+ *   import { client } from './fturex';
+ *
+ *   const feature = useFeatureToggle(client, 'new-dashboard');
+ * </script>
+ *
+ * {#if $feature.loading}
+ *   <Spinner />
+ * {:else if $feature.isEnabled}
+ *   <NewDashboard />
+ * {:else}
+ *   <LegacyDashboard />
+ * {/if}
+ */
+export function useFeatureToggle(client, featureName, context) {
+    return readable({ isEnabled: false, loading: true, error: null }, (set) => {
+        const evaluate = async () => {
+            try {
+                const enabled = context
+                    ? await client.isEnabledWithContext(featureName, context)
+                    : await client.isEnabled(featureName);
+                set({ isEnabled: enabled, loading: false, error: null });
+            }
+            catch (err) {
+                set({ isEnabled: false, loading: false, error: err });
+            }
+        };
+        client.on('update', evaluate);
+        client.on('ready', evaluate);
+        evaluate();
+        return () => {
+            client.off('update', evaluate);
+            client.off('ready', evaluate);
+        };
+    });
+}
+/**
+ * Creates a Svelte readable store that resolves to a map of feature toggle states.
+ * Re-evaluates automatically whenever the client refreshes its manifest.
+ *
+ * @example
+ * <script>
+ *   import { useFeatureToggles } from 'fturex/svelte';
+ *   import { client } from './fturex';
+ *
+ *   const features = useFeatureToggles(client, ['feature-a', 'feature-b']);
+ * </script>
+ *
+ * {#if !$features.loading}
+ *   {#if $features.features['feature-a']}
+ *     <FeatureA />
+ *   {/if}
+ * {/if}
+ */
+export function useFeatureToggles(client, featureNames) {
+    return readable({ features: {}, loading: true, error: null }, (set) => {
+        const evaluate = async () => {
+            try {
+                const results = {};
+                await Promise.all(featureNames.map(async (name) => {
+                    results[name] = await client.isEnabled(name);
+                }));
+                set({ features: results, loading: false, error: null });
+            }
+            catch (err) {
+                set({ features: {}, loading: false, error: err });
+            }
+        };
+        client.on('update', evaluate);
+        client.on('ready', evaluate);
+        evaluate();
+        return () => {
+            client.off('update', evaluate);
+            client.off('ready', evaluate);
+        };
+    });
+}