@anterprize/fturex 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @anterprize/fturex
+
+Feature toggle client for React, Vue, Angular, and Svelte applications.
+
+Fetches your full feature manifest in the background and evaluates flags locally — no per-call network round-trips. Supports context-based targeting (user, role, tenant, etc.), automatic background refresh, localStorage persistence, and usage statistics.
+
+## Installation
+
+```bash
+npm install @anterprize/fturex
+```
+
+## Quick start
+
+```typescript
+import { FtureXClient } from '@anterprize/fturex';
+
+const client = new FtureXClient(
+  { baseUrl: 'https://your-api.com', appKey: 'your-app-key' },
+  { refreshIntervalSeconds: 30 }
+);
+
+await client.initialize();
+
+if (await client.isEnabled('my-feature')) {
+  // feature is on
+}
+
+// With context
+if (await client.isEnabledWithContext('beta-feature', { role: 'admin', userId: 'user-123' })) {
+  // feature is on for this user
+}
+
+client.dispose();
+```
+
+---
+
+## React
+
+```tsx
+import { FeatureToggleProvider, useFeatureToggle, FeatureToggle } from '@anterprize/fturex/react';
+
+// Wrap your app
+export function App() {
+  return (
+    <FeatureToggleProvider config={{ baseUrl: '...', appKey: '...' }}>
+      <MyApp />
+    </FeatureToggleProvider>
+  );
+}
+
+// Hook
+function MyComponent() {
+  const { isEnabled, loading } = useFeatureToggle('my-feature');
+  if (loading) return <Spinner />;
+  return isEnabled ? <NewUI /> : <OldUI />;
+}
+
+// Component
+function MyOtherComponent() {
+  return (
+    <FeatureToggle featureName="my-feature">
+      <NewUI />
+    </FeatureToggle>
+  );
+}
+```
+
+---
+
+## Vue
+
+```ts
+// main.ts
+import { createApp } from 'vue';
+import { FtureXClient } from '@anterprize/fturex';
+import { FeatureToggleClientKey } from '@anterprize/fturex/vue';
+
+const client = new FtureXClient({ baseUrl: '...', appKey: '...' });
+await client.initialize();
+
+const app = createApp(App);
+app.provide(FeatureToggleClientKey, client);
+app.mount('#app');
+```
+
+```vue
+<!-- MyComponent.vue -->
+<script setup lang="ts">
+import { useFeatureToggle } from '@anterprize/fturex/vue';
+
+const { isEnabled, loading } = useFeatureToggle('my-feature');
+</script>
+
+<template>
+  <NewUI v-if="!loading && isEnabled" />
+  <OldUI v-else-if="!loading" />
+</template>
+```
+
+SFC component (requires Vue SFC compiler):
+
+```ts
+import FeatureToggle from '@anterprize/fturex/vue/FeatureToggle.vue';
+```
+
+---
+
+## Angular
+
+```ts
+// app.module.ts
+import { FtureXModule } from '@anterprize/fturex/angular';
+
+@NgModule({
+  imports: [
+    FtureXModule.forRoot({ baseUrl: '...', appKey: '...' })
+  ]
+})
+export class AppModule {}
+```
+
+```ts
+// my.component.ts
+import { FtureXService } from '@anterprize/fturex/angular';
+
+@Component({ ... })
+export class MyComponent {
+  isEnabled = false;
+
+  constructor(private fturex: FtureXService) {}
+
+  async ngOnInit() {
+    this.isEnabled = await this.fturex.isEnabled('my-feature');
+  }
+}
+```
+
+```html
+<!-- Template directive -->
+<div *featureToggle="'my-feature'">Only shown when feature is enabled</div>
+
+<!-- Pipe -->
+<div *ngIf="'my-feature' | featureToggle | async">...</div>
+```
+
+---
+
+## Svelte
+
+```ts
+// fturex.ts
+import { FtureXClient } from '@anterprize/fturex';
+
+export const client = new FtureXClient({ baseUrl: '...', appKey: '...' });
+await client.initialize();
+```
+
+```svelte
+<!-- MyComponent.svelte -->
+<script>
+  import { useFeatureToggle } from '@anterprize/fturex/svelte';
+  import { client } from './fturex';
+
+  const feature = useFeatureToggle(client, 'my-feature');
+</script>
+
+{#if $feature.loading}
+  <Spinner />
+{:else if $feature.isEnabled}
+  <NewUI />
+{:else}
+  <OldUI />
+{/if}
+```
+
+---
+
+## OpenTelemetry
+
+```ts
+import { FtureXClient } from '@anterprize/fturex';
+import { FtureXOtelHook } from '@anterprize/fturex/opentelemetry';
+
+const client = new FtureXClient({ baseUrl: '...', appKey: '...' });
+client.addHook(new FtureXOtelHook());
+await client.initialize();
+```
+
+---
+
+## Configuration
+
+### `FtureXConfiguration`
+
+| Property | Type | Required | Description |
+|---|---|---|---|
+| `baseUrl` | `string` | yes | API base URL |
+| `appKey` | `string` | yes | API authentication key |
+| `sendStatistics` | `boolean` | no | Report usage statistics (default: `true`) |
+
+### `FeatureCacheOptions`
+
+| Property | Type | Default | Description |
+|---|---|---|---|
+| `refreshIntervalSeconds` | `number` | `30` | How often the manifest is refreshed |
+| `enableLocalStoragePersistence` | `boolean` | `true` | Persist manifest to `localStorage` |
+| `localStorageKey` | `string` | `feature-toggle-cache` | `localStorage` key |
+
+---
+
+## Events
+
+```typescript
+client.on('ready', () => console.log('Manifest loaded'));
+client.on('update', () => console.log('Manifest refreshed'));
+
+client.off('update', handler);
+```
+
+---
+
+## License
+
+MIT — [Anterprize](https://github.com/Anterprize)

package/dist/FtureXClient.d.ts

@@ -0,0 +1,72 @@
+import { FtureXConfiguration, FeatureCacheOptions, ContextProperties, FeatureStatistics, FtureXHook } from "./types.js";
+/**
+ * FtureX Client
+ * Fetches the full feature manifest in the background and evaluates
+ * conditions locally — no per-call network round-trips.
+ */
+export declare class FtureXClient {
+    private config;
+    private cacheOptions;
+    private hooks;
+    private manifest;
+    private listeners;
+    private featureHitCounts;
+    private featureEnabledCounts;
+    private featureDisabledCounts;
+    private featureLastAccessed;
+    private refreshIntervalId?;
+    private statisticsIntervalId?;
+    constructor(config: FtureXConfiguration, cacheOptions?: FeatureCacheOptions);
+    /**
+     * Subscribe to an event.
+     * - 'ready'  — fires once after the first successful manifest fetch
+     * - 'update' — fires after every subsequent manifest refresh
+     */
+    on(event: "update" | "ready", callback: () => void): void;
+    /** Unsubscribe a previously registered callback. */
+    off(event: "update" | "ready", callback: () => void): void;
+    private emit;
+    /**
+     * Initialize the client — loads persisted manifest and starts background services
+     */
+    initialize(): Promise<void>;
+    /**
+     * Stop all background services
+     */
+    dispose(): void;
+    /**
+     * Register a hook that will be called for every flag evaluation.
+     */
+    addHook(hook: FtureXHook): void;
+    /**
+     * Check if a feature is enabled (no context)
+     */
+    isEnabled(featureName: string): Promise<boolean>;
+    /**
+     * Check if a feature is enabled with context properties evaluated locally
+     */
+    isEnabledWithContext(featureName: string, context: ContextProperties): Promise<boolean>;
+    private determineReason;
+    private invokeHooksBefore;
+    private invokeHooksAfter;
+    private invokeHooksError;
+    private findEntry;
+    private evaluateEntry;
+    private evaluateConditions;
+    /** Returns true only when ALL rules in the segment match. */
+    private evaluateAndSegment;
+    private evaluateDirectValueCondition;
+    private evaluateValueListCondition;
+    private orderCommaSeparated;
+    private refreshManifest;
+    private fetchManifestFromApi;
+    private startBackgroundRefresh;
+    private startStatisticsReporting;
+    private trackFeatureHit;
+    private sendStatistics;
+    private resetStatistics;
+    getStatistics(): FeatureStatistics[];
+    private saveManifestToStorage;
+    private loadManifestFromStorage;
+    clearCache(): void;
+}