react-achievements 4.4.1 → 5.0.1

package/dist/headless.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import * as achievements_engine from 'achievements-engine';
-import { AchievementSnapshot, ImportOptions, ImportResult, AchievementEngine, AchievementStorage as AchievementStorage$1, AsyncAchievementStorage as AsyncAchievementStorage$1, StorageType, RestApiStorageConfig, EventMapping, AchievementError } from 'achievements-engine';
+import { AchievementUpdateResult, ImportOptions, ImportResult, AchievementEngine, AchievementStorage as AchievementStorage$1, AsyncAchievementStorage as AsyncAchievementStorage$1, StorageType, RestApiStorageConfig, EventMapping, AchievementError } from 'achievements-engine';
 export { AchievementBuilder, AchievementEngine, AchievementEngineApi, AchievementError, AchievementSnapshot, AchievementUnlockedEvent, AchievementUpdateResult, AsyncStorageAdapter, AwardDetails, ConfigurationError, EngineConfig, EngineEvent, ErrorEvent, EventMapping, ExportedData, ImportOptions, ImportResult, ImportValidationError, IndexedDBStorage, LocalStorage, MemoryStorage, MetricUpdatedEvent, MetricUpdater, OfflineQueueStorage, RestApiStorage, RestApiStorageConfig, StateChangedEvent, StorageError, StorageQuotaError, StorageType, SyncError, UnsubscribeFn, createConfigHash, exportAchievementData, importAchievementData, isAchievementError, isRecoverableError, isSimpleConfig, normalizeAchievements } from 'achievements-engine';
 
 type ConfettiShape = 'square' | 'circle' | 'star';
@@ -34,6 +34,13 @@ interface AchievementDetails {
 }
 interface AchievementWithStatus extends AchievementDetails {
     isUnlocked: boolean;
+    unlockedAt?: string | null;
+    progress?: {
+        current: number;
+        target: number;
+        percent: number;
+    };
+    metadata?: Record<string, unknown>;
 }
 type AchievementConfetti = false | ConfettiOptions;
 interface AchievementCondition {
@@ -102,14 +109,63 @@ interface AchievementContextValue {
     resetStorage: () => void;
 }
 
+interface AchievementProgress {
+    current: number;
+    target: number;
+    percent: number;
+}
+interface AchievementDto {
+    id: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    iconKey?: string;
+    isUnlocked: boolean;
+    unlockedAt?: string | null;
+    progress?: AchievementProgress;
+    metadata?: Record<string, unknown>;
+    confetti?: AchievementConfetti;
+}
+interface AchievementClientSnapshot {
+    achievements: AchievementDto[];
+    unlockedIds: string[];
+    unlockedAchievements: AchievementDto[];
+    unlockedCount: number;
+    totalCount: number;
+    metrics?: Record<string, unknown>;
+}
+interface AchievementClientMutationResult {
+    snapshot: AchievementClientSnapshot;
+    newlyUnlocked: AchievementDto[];
+}
+interface AchievementClient {
+    getSnapshot(): Promise<AchievementClientSnapshot>;
+    track(metric: string, value: unknown): Promise<AchievementClientMutationResult>;
+    trackMany?(metrics: Record<string, unknown>): Promise<AchievementClientMutationResult>;
+    increment(metric: string, amount?: number): Promise<AchievementClientMutationResult>;
+    event(name: string, payload?: unknown): Promise<AchievementClientMutationResult>;
+    reset?(): Promise<AchievementClientSnapshot>;
+}
+
+interface AchievementSnapshot {
+    metrics: Record<string, any>;
+    unlockedIds: string[];
+    unlockedAchievements: AchievementWithStatus[];
+    allAchievements: AchievementWithStatus[];
+    unlockedCount: number;
+    totalCount: number;
+}
 interface AchievementContextType {
-    update: (metrics: Record<string, any>) => void;
+    update: (metrics: Record<string, any>) => void | AchievementUpdateResult | Promise<AchievementClientMutationResult | void>;
+    increment: (metric: string, amount?: number) => AchievementUpdateResult | Promise<AchievementClientMutationResult | void> | void;
+    event: (name: string, payload?: unknown) => Promise<AchievementClientMutationResult | void> | void;
+    refresh: () => Promise<AchievementSnapshot>;
     achievements: {
         unlocked: string[];
         all: Record<string, AchievementWithStatus>;
     };
     snapshot: AchievementSnapshot;
-    reset: () => void;
+    reset: () => void | Promise<void>;
     getState: () => {
         metrics: Record<string, any>;
         unlocked: string[];
@@ -117,8 +173,12 @@ interface AchievementContextType {
     exportData: () => string;
     importData: (jsonString: string, options?: ImportOptions) => ImportResult;
     getAllAchievements: () => AchievementWithStatus[];
-    engine: AchievementEngine;
+    engine?: AchievementEngine;
+    client?: AchievementClient;
     icons: Record<string, string>;
+    recentlyUnlocked: AchievementWithStatus[];
+    isLoading: boolean;
+    error: Error | null;
     /**
      * @deprecated Use provider props or the presence of an injected engine directly.
      * This compatibility flag will be removed in 5.0.
@@ -127,6 +187,7 @@ interface AchievementContextType {
 }
 declare const AchievementContext: React.Context<AchievementContextType | undefined>;
 interface AchievementProviderProps {
+    client?: AchievementClient;
     achievements?: AchievementConfigurationType;
     storage?: AchievementStorage$1 | AsyncAchievementStorage$1 | StorageType;
     restApiConfig?: RestApiStorageConfig;
@@ -150,23 +211,28 @@ declare const useAchievements: () => AchievementContextType;
  * Provides the v4 happy path for direct metric updates plus explicit state names.
  */
 declare const useSimpleAchievements: () => {
-    track: (metric: string, value: any) => void;
-    increment: (metric: string, amount?: number) => achievements_engine.AchievementUpdateResult;
-    trackMultiple: (metrics: Record<string, any>) => void;
+    track: (metric: string, value: any) => void | achievements_engine.AchievementUpdateResult | Promise<void | AchievementClientMutationResult>;
+    increment: (metric: string, amount?: number) => void | achievements_engine.AchievementUpdateResult | Promise<void | AchievementClientMutationResult>;
+    trackMultiple: (metrics: Record<string, any>) => void | achievements_engine.AchievementUpdateResult | Promise<void | AchievementClientMutationResult>;
     unlockedIds: string[];
-    unlockedAchievements: achievements_engine.AchievementWithStatus[];
-    allAchievements: achievements_engine.AchievementWithStatus[];
+    unlockedAchievements: AchievementWithStatus[];
+    allAchievements: AchievementWithStatus[];
     unlockedCount: number;
     totalCount: number;
-    metrics: achievements_engine.AchievementMetrics;
-    reset: () => void;
+    metrics: Record<string, any>;
+    isLoading: boolean;
+    error: Error | null;
+    event: (name: string, payload?: unknown) => Promise<AchievementClientMutationResult | void> | void;
+    emit: (name: string, payload?: unknown) => Promise<AchievementClientMutationResult | void> | void;
+    refresh: () => Promise<AchievementSnapshot>;
+    reset: () => void | Promise<void>;
     getState: () => {
         metrics: Record<string, any>;
         unlocked: string[];
     };
     exportData: () => string;
     importData: (jsonString: string, options?: achievements_engine.ImportOptions) => achievements_engine.ImportResult;
-    getAllAchievements: () => achievements_engine.AchievementWithStatus[];
+    getAllAchievements: () => AchievementWithStatus[];
     /**
      * @deprecated Use `unlockedIds` instead. This alias will be removed in 5.0.
      */
@@ -174,16 +240,16 @@ declare const useSimpleAchievements: () => {
     /**
      * @deprecated Use `allAchievements` instead. This alias will be removed in 5.0.
      */
-    all: achievements_engine.AchievementWithStatus[];
+    all: AchievementWithStatus[];
 };
 
 declare const useAchievementState: () => {
     unlockedIds: string[];
-    unlockedAchievements: achievements_engine.AchievementWithStatus[];
-    allAchievements: achievements_engine.AchievementWithStatus[];
+    unlockedAchievements: AchievementWithStatus[];
+    allAchievements: AchievementWithStatus[];
     unlockedCount: number;
     totalCount: number;
-    metrics: achievements_engine.AchievementMetrics;
+    metrics: Record<string, any>;
 };
 
 /**
@@ -194,4 +260,30 @@ declare const useAchievementState: () => {
  */
 declare const useAchievementEngine: () => AchievementEngine;
 
-export { AchievementCondition, AchievementConfetti, AchievementConfiguration, AchievementConfigurationType, AchievementContext, AchievementContextType, AchievementContextValue, AchievementDetails, AchievementMetricArrayValue, AchievementMetricValue, AchievementMetrics, AchievementProvider, AchievementProviderProps, AchievementState, AchievementStorage, AchievementWithStatus, AnyAchievementStorage, AsyncAchievementStorage, CustomAchievementDetails, InitialAchievementMetrics, SimpleAchievementConfig, SimpleAchievementDetails, isAsyncStorage, useAchievementEngine, useAchievementState, useAchievements, useSimpleAchievements };
+type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+interface RestAchievementClientConfig {
+    baseUrl: string;
+    fetcher?: Fetcher;
+    headers?: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
+    credentials?: RequestCredentials;
+    timeout?: number;
+}
+declare class RestAchievementClient implements AchievementClient {
+    private baseUrl;
+    private fetcher;
+    private headers?;
+    private credentials?;
+    private timeout?;
+    constructor(config: RestAchievementClientConfig);
+    getSnapshot(): Promise<AchievementClientSnapshot>;
+    track(metric: string, value: unknown): Promise<AchievementClientMutationResult>;
+    trackMany(metrics: Record<string, unknown>): Promise<AchievementClientMutationResult>;
+    increment(metric: string, amount?: number): Promise<AchievementClientMutationResult>;
+    event(name: string, payload?: unknown): Promise<AchievementClientMutationResult>;
+    reset(): Promise<AchievementClientSnapshot>;
+    private request;
+    private resolveHeaders;
+}
+declare const createRestAchievementClient: (config: RestAchievementClientConfig) => AchievementClient;
+
+export { AchievementClient, AchievementClientMutationResult, AchievementClientSnapshot, AchievementCondition, AchievementConfetti, AchievementConfiguration, AchievementConfigurationType, AchievementContext, AchievementContextType, AchievementContextValue, AchievementDetails, AchievementDto, AchievementMetricArrayValue, AchievementMetricValue, AchievementMetrics, AchievementProgress, AchievementProvider, AchievementProviderProps, AchievementState, AchievementStorage, AchievementWithStatus, AnyAchievementStorage, AsyncAchievementStorage, CustomAchievementDetails, InitialAchievementMetrics, RestAchievementClient, RestAchievementClientConfig, SimpleAchievementConfig, SimpleAchievementDetails, createRestAchievementClient, isAsyncStorage, useAchievementEngine, useAchievementState, useAchievements, useSimpleAchievements };

package/dist/headless.esm.js

@@ -16,6 +16,38 @@ var StorageType;
     StorageType["RestAPI"] = "restapi"; // Asynchronous REST API storage
 })(StorageType || (StorageType = {}));
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
 const warnedMessages = new Set();
 function warnDeprecation(message) {
     var _a, _b;
@@ -32,18 +64,74 @@ const AchievementContext = createContext(undefined);
 const getAllAchievementRecord = (achievements) => {
     return Object.fromEntries(achievements.map((achievement) => [achievement.achievementId, achievement]));
 };
-const AchievementProvider = ({ achievements: achievementsConfig, storage = 'local', children, onError, useBuiltInUI, restApiConfig, engine: externalEngine, eventMapping, icons = {}, }) => {
+const emptySnapshot = () => ({
+    metrics: {},
+    unlockedIds: [],
+    unlockedAchievements: [],
+    allAchievements: [],
+    unlockedCount: 0,
+    totalCount: 0,
+});
+const normalizeAchievementDto = (achievement) => {
+    const source = achievement;
+    const achievementId = source.id || source.achievementId || '';
+    const achievementTitle = source.title || source.achievementTitle || achievementId;
+    const achievementDescription = source.description || source.achievementDescription || '';
+    const achievementIconKey = source.iconKey || source.icon || source.achievementIconKey;
+    return {
+        achievementId,
+        achievementTitle,
+        achievementDescription,
+        achievementIconKey,
+        confetti: source.confetti,
+        isUnlocked: Boolean(source.isUnlocked),
+        unlockedAt: source.unlockedAt,
+        progress: source.progress,
+        metadata: source.metadata,
+    };
+};
+const normalizeClientSnapshot = (snapshot) => {
+    var _a, _b, _c;
+    const allAchievements = (snapshot.achievements || []).map(normalizeAchievementDto);
+    const unlockedIds = snapshot.unlockedIds ||
+        allAchievements
+            .filter((achievement) => achievement.isUnlocked)
+            .map((achievement) => achievement.achievementId);
+    const unlockedIdSet = new Set(unlockedIds);
+    const unlockedAchievements = ((_a = snapshot.unlockedAchievements) === null || _a === void 0 ? void 0 : _a.length)
+        ? snapshot.unlockedAchievements.map(normalizeAchievementDto)
+        : allAchievements.filter((achievement) => unlockedIdSet.has(achievement.achievementId));
+    return {
+        metrics: Object.assign({}, (snapshot.metrics || {})),
+        unlockedIds,
+        unlockedAchievements,
+        allAchievements,
+        unlockedCount: (_b = snapshot.unlockedCount) !== null && _b !== void 0 ? _b : unlockedAchievements.length,
+        totalCount: (_c = snapshot.totalCount) !== null && _c !== void 0 ? _c : allAchievements.length,
+    };
+};
+const toError = (unknownError, fallbackMessage) => (unknownError instanceof Error ? unknownError : new Error(fallbackMessage));
+const AchievementProvider = ({ client, achievements: achievementsConfig, storage = 'local', children, onError, useBuiltInUI, restApiConfig, engine: externalEngine, eventMapping, icons = {}, }) => {
     if (useBuiltInUI !== undefined) {
         warnDeprecation('`useBuiltInUI` is deprecated and is now a no-op because built-in UI is the default. It will be removed in 5.0.');
     }
+    if (client && (achievementsConfig || externalEngine)) {
+        throw new Error('Cannot provide "client" with "achievements" or "engine" props to AchievementProvider.\n\n' +
+            'Use one pattern:\n' +
+            '1. Server-backed display: <AchievementProvider client={achievementClient}>\n' +
+            '2. Legacy in-browser engine: <AchievementProvider achievements={config}>');
+    }
     if (achievementsConfig && externalEngine) {
         throw new Error('Cannot provide both "achievements" and "engine" props to AchievementProvider.\n\n' +
             'Choose one pattern:\n' +
             '1. Direct metric tracking: <AchievementProvider achievements={config}>\n' +
             '2. Event-based tracking: <AchievementProvider engine={myEngine}>');
     }
-    const isProviderCreatedEngine = Boolean(achievementsConfig);
+    const isProviderCreatedEngine = Boolean(achievementsConfig) && !client;
     const [engine] = useState(() => {
+        if (client) {
+            return undefined;
+        }
         if (externalEngine) {
             return externalEngine;
         }
@@ -60,18 +148,63 @@ const AchievementProvider = ({ achievements: achievementsConfig, storage = 'loca
             eventMapping,
         });
     });
-    const [achievementSnapshot, setAchievementSnapshot] = useState(() => engine.getSnapshot());
+    const [achievementSnapshot, setAchievementSnapshot] = useState(() => engine ? engine.getSnapshot() : emptySnapshot());
+    const [recentlyUnlocked, setRecentlyUnlocked] = useState([]);
+    const [isLoading, setIsLoading] = useState(Boolean(client));
+    const [error, setError] = useState(null);
     const syncAchievementState = useCallback((snapshot) => {
-        setAchievementSnapshot(snapshot || engine.getSnapshot());
+        if (snapshot) {
+            setAchievementSnapshot(snapshot);
+            return;
+        }
+        if (engine) {
+            setAchievementSnapshot(engine.getSnapshot());
+        }
     }, [engine]);
+    const applyClientMutationResult = useCallback((result) => {
+        setRecentlyUnlocked((result.newlyUnlocked || []).map(normalizeAchievementDto));
+        const normalizedSnapshot = normalizeClientSnapshot(result.snapshot);
+        setAchievementSnapshot(normalizedSnapshot);
+        return result;
+    }, []);
+    const refresh = useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
+        if (!client) {
+            const snapshot = engine ? engine.getSnapshot() : emptySnapshot();
+            setAchievementSnapshot(snapshot);
+            return snapshot;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const snapshot = normalizeClientSnapshot(yield client.getSnapshot());
+            setAchievementSnapshot(snapshot);
+            return snapshot;
+        }
+        catch (unknownError) {
+            const nextError = toError(unknownError, 'Failed to load achievements');
+            setError(nextError);
+            throw nextError;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [client, engine]);
+    const handleClientMutationFailure = useCallback((unknownError) => {
+        const nextError = toError(unknownError, 'Failed to update achievements');
+        setError(nextError);
+        throw nextError;
+    }, []);
     useEffect(() => {
         return () => {
-            if (!externalEngine) {
+            if (engine && !externalEngine) {
                 engine.destroy();
             }
         };
     }, [engine, externalEngine]);
     useEffect(() => {
+        if (!engine) {
+            return;
+        }
         let isMounted = true;
         const unsubscribeStateChanged = engine.on('state:changed', (event) => {
             syncAchievementState(event);
@@ -86,29 +219,84 @@ const AchievementProvider = ({ achievements: achievementsConfig, storage = 'loca
             unsubscribeStateChanged();
         };
     }, [engine, syncAchievementState]);
+    useEffect(() => {
+        if (!client) {
+            return;
+        }
+        refresh().catch(() => {
+        });
+        return () => {
+        };
+    }, [client, refresh]);
     const update = (newMetrics) => {
-        engine.update(newMetrics);
+        if (client) {
+            setError(null);
+            const mutation = client.trackMany
+                ? client.trackMany(newMetrics)
+                : Promise.all(Object.entries(newMetrics).map(([metric, value]) => client.track(metric, value))).then((results) => results[results.length - 1]);
+            return mutation.then((result) => {
+                if (result) {
+                    applyClientMutationResult(result);
+                }
+                return result;
+            }).catch(handleClientMutationFailure);
+        }
+        return engine === null || engine === void 0 ? void 0 : engine.update(newMetrics);
+    };
+    const increment = (metric, amount = 1) => {
+        if (client) {
+            setError(null);
+            return client.increment(metric, amount)
+                .then(applyClientMutationResult)
+                .catch(handleClientMutationFailure);
+        }
+        return engine === null || engine === void 0 ? void 0 : engine.increment(metric, amount);
+    };
+    const event = (name, payload) => {
+        if (client) {
+            setError(null);
+            return client.event(name, payload)
+                .then(applyClientMutationResult)
+                .catch(handleClientMutationFailure);
+        }
+        engine === null || engine === void 0 ? void 0 : engine.emit(name, payload);
     };
     const reset = () => {
-        engine.reset();
+        if (client === null || client === void 0 ? void 0 : client.reset) {
+            setError(null);
+            return client.reset().then((snapshot) => {
+                setRecentlyUnlocked([]);
+                setAchievementSnapshot(normalizeClientSnapshot(snapshot));
+            }).catch(handleClientMutationFailure);
+        }
+        if (client) {
+            return refresh().then(() => undefined);
+        }
+        engine === null || engine === void 0 ? void 0 : engine.reset();
     };
     const getState = () => {
-        const snapshot = engine.getSnapshot();
+        const snapshot = engine ? engine.getSnapshot() : achievementSnapshot;
         return {
             metrics: snapshot.metrics,
             unlocked: snapshot.unlockedIds,
         };
     };
     const exportData = () => {
-        return engine.export();
+        return engine ? engine.export() : JSON.stringify(achievementSnapshot);
     };
     const importData = (jsonString, options) => {
+        if (!engine) {
+            return {
+                success: false,
+                errors: ['importData is not supported by remote achievement clients. Import on the server instead.'],
+            };
+        }
         const result = engine.import(jsonString, options);
         syncAchievementState();
         return result;
     };
     const getAllAchievements = () => {
-        return engine.getSnapshot().allAchievements;
+        return engine ? engine.getSnapshot().allAchievements : achievementSnapshot.allAchievements;
     };
     const achievements = {
         unlocked: achievementSnapshot.unlockedIds,
@@ -116,6 +304,9 @@ const AchievementProvider = ({ achievements: achievementsConfig, storage = 'loca
     };
     return (React.createElement(AchievementContext.Provider, { value: {
             update,
+            increment,
+            event,
+            refresh,
             achievements,
             snapshot: achievementSnapshot,
             reset,
@@ -124,7 +315,11 @@ const AchievementProvider = ({ achievements: achievementsConfig, storage = 'loca
             importData,
             getAllAchievements,
             engine,
+            client,
             icons,
+            recentlyUnlocked,
+            isLoading,
+            error,
             _isLegacyPattern: isProviderCreatedEngine,
         } }, children));
 };
@@ -154,11 +349,11 @@ const useAchievementState = () => {
  * Provides the v4 happy path for direct metric updates plus explicit state names.
  */
 const useSimpleAchievements = () => {
-    const { update, reset, getState, exportData, importData, engine } = useAchievements();
+    const { update, increment: incrementMetric, event, refresh, reset, getState, exportData, importData, isLoading, error, } = useAchievements();
     const achievementState = useAchievementState();
     const track = (metric, value) => update({ [metric]: value });
     const increment = (metric, amount = 1) => {
-        return engine.increment(metric, amount);
+        return incrementMetric(metric, amount);
     };
     const trackMultiple = (metrics) => update(metrics);
     return {
@@ -171,6 +366,11 @@ const useSimpleAchievements = () => {
         unlockedCount: achievementState.unlockedCount,
         totalCount: achievementState.totalCount,
         metrics: achievementState.metrics,
+        isLoading,
+        error,
+        event,
+        emit: event,
+        refresh,
         reset,
         getState,
         exportData,
@@ -202,8 +402,94 @@ const useAchievementEngine = () => {
             '  <YourComponent />\n' +
             '</AchievementProvider>');
     }
+    if (!context.engine) {
+        throw new Error('useAchievementEngine is only available when AchievementProvider is using the legacy in-browser engine. ' +
+            'For server-backed achievements, use useSimpleAchievements().event(), track(), or increment().');
+    }
     return context.engine;
 };
 
-export { AchievementContext, AchievementProvider, isAsyncStorage, useAchievementEngine, useAchievementState, useAchievements, useSimpleAchievements };
+const trimTrailingSlash = (value) => value.replace(/\/$/, '');
+class RestAchievementClient {
+    constructor(config) {
+        this.baseUrl = trimTrailingSlash(config.baseUrl);
+        this.fetcher = config.fetcher || fetch.bind(globalThis);
+        this.headers = config.headers;
+        this.credentials = config.credentials;
+        this.timeout = config.timeout;
+    }
+    getSnapshot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('', { method: 'GET' });
+        });
+    }
+    track(metric, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('/track', {
+                method: 'POST',
+                body: JSON.stringify({ metric, value }),
+            });
+        });
+    }
+    trackMany(metrics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('/track', {
+                method: 'POST',
+                body: JSON.stringify({ metrics }),
+            });
+        });
+    }
+    increment(metric_1) {
+        return __awaiter(this, arguments, void 0, function* (metric, amount = 1) {
+            return this.request('/increment', {
+                method: 'POST',
+                body: JSON.stringify({ metric, amount }),
+            });
+        });
+    }
+    event(name, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('/event', {
+                method: 'POST',
+                body: JSON.stringify({ name, payload }),
+            });
+        });
+    }
+    reset() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('/reset', { method: 'POST' });
+        });
+    }
+    request(path, init) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controller = this.timeout ? new AbortController() : undefined;
+            const timeoutId = controller
+                ? setTimeout(() => controller.abort(), this.timeout)
+                : undefined;
+            try {
+                const response = yield this.fetcher(`${this.baseUrl}${path}`, Object.assign(Object.assign({}, init), { credentials: this.credentials, headers: Object.assign(Object.assign({ 'Content-Type': 'application/json' }, (yield this.resolveHeaders())), init.headers), signal: controller === null || controller === void 0 ? void 0 : controller.signal }));
+                if (!response.ok) {
+                    throw new Error(`Achievement request failed: HTTP ${response.status}`);
+                }
+                return yield response.json();
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        });
+    }
+    resolveHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.headers) {
+                return {};
+            }
+            return typeof this.headers === 'function' ? this.headers() : this.headers;
+        });
+    }
+}
+const createRestAchievementClient = (config) => new RestAchievementClient(config);
+
+export { AchievementContext, AchievementProvider, RestAchievementClient, createRestAchievementClient, isAsyncStorage, useAchievementEngine, useAchievementState, useAchievements, useSimpleAchievements };
 //# sourceMappingURL=headless.esm.js.map