@mapvx/web-js 3.6.0-dev.1 → 4.0.0

package/dist/cjs/repository/repository.js

@@ -1,694 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Repository = void 0;
-const campaign_1 = require("../domain/models/campaign");
-const institution_1 = require("../domain/models/institution");
-const loggeable_1 = require("../domain/models/loggeable");
-const place_1 = require("../domain/models/place");
-const route_1 = require("../domain/models/route");
-const transport_1 = require("../domain/models/transport");
-const CacheManager_1 = require("../infrastructure/cache/CacheManager");
-const requester_1 = require("./requester");
-/**
- * Extracts a human-readable error message from an API error response body.
- * Handles various response formats: string, object with message/error field, or falls back to JSON.
- * @param errorBody - The parsed JSON body from an error response
- * @returns A string representation of the error
- * @hidden
- */
-function extractErrorMessage(errorBody) {
-    if (typeof errorBody === "string")
-        return errorBody;
-    if (errorBody && typeof errorBody === "object") {
-        const obj = errorBody;
-        if (typeof obj.message === "string")
-            return obj.message;
-        if (typeof obj.error === "string")
-            return obj.error;
-    }
-    return JSON.stringify(errorBody);
-}
-/**
- * Represents the repository for the SDK.
- * @hidden
- */
-class Repository extends loggeable_1.Loggeable {
-    constructor(token, lang, apiUrl, cache, mapvxRequestContext, endpoints) {
-        super();
-        this.currentLang = "en";
-        this.token = token;
-        this.currentLang = lang;
-        this.requester = new requester_1.Requester(lang, apiUrl, mapvxRequestContext, endpoints);
-        this.cache = cache !== null && cache !== void 0 ? cache : new CacheManager_1.CacheManager();
-    }
-    /**
-     * function to change the lang of requests
-     * @param lang request response language
-     */
-    setLang(lang) {
-        this.currentLang = lang;
-        this.requester.setLang(lang);
-    }
-    prepareSegmentation(segmentation) {
-        return Object.assign(Object.assign({}, segmentation), { token: this.token });
-    }
-    async fetchAndParseMapStyle(placeId, styleRef, styleTheme) {
-        // `baseStyle` caches only the default (no place, no explicit preview ref/theme).
-        const cacheable = placeId === undefined && styleRef === undefined && styleTheme === undefined;
-        if (cacheable && this.baseStyle) {
-            return this.baseStyle;
-        }
-        try {
-            const response = await this.requester.fetchMapStyle(this.token, placeId, styleRef, styleTheme);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const style = responseData.style;
-            if (cacheable) {
-                this.baseStyle = style;
-            }
-            this.logEvent("fetchAndParseMapStyle");
-            return style;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseMapStyle" });
-            throw new Error("Failed to fetch and parse map style", { cause: error });
-        }
-    }
-    /**
-     * Bearer-authenticated style fetch: resolves a style by explicit ref/theme for
-     * a place through the bearer map style endpoint, authorized by the user's
-     * client access instead of the api key's scopes. Mirrors
-     * {@link fetchAndParseMapStyle} but with a user bearer token.
-     */
-    async fetchAndParseMapStyleByBearer(placeId, authToken, styleRef, styleTheme) {
-        try {
-            const response = await this.requester.fetchMapStyleByBearer(authToken, placeId, styleRef, styleTheme);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const style = responseData.style;
-            this.logEvent("fetchAndParseMapStyleByBearer");
-            return style;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseMapStyleByBearer" });
-            throw new Error("Failed to fetch and parse map style with bearer token", {
-                cause: error,
-            });
-        }
-    }
-    async fetchAndParseAnyMapStyle(institutionId, authToken) {
-        try {
-            const response = await this.requester.fetchAnyMapStyle(authToken, institutionId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const style = responseData.style;
-            this.logEvent("fetchAndParseAnyMapStyle");
-            return style;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseAnyMapStyle" });
-            throw new Error("Failed to fetch and parse map style with bearer token", { cause: error });
-        }
-    }
-    async fetchAndParseInstitutions() {
-        try {
-            const response = await this.requester.fetchInstitutions(this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const institutions = [];
-            for (const institutionData of responseData) {
-                const institution = new institution_1.Institution(institutionData);
-                institutions.push(institution);
-            }
-            institutions.sort((a, b) => a.title.localeCompare(b.title));
-            const resultInstitution = institutions;
-            if (resultInstitution) {
-                this.logEvent("fetchAndParseInstitutionsV2");
-                return resultInstitution;
-            }
-            else {
-                throw new Error("No institutions associated to this apiKey");
-            }
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseInstitutionsV2" });
-            throw new Error("Failed to fetch and parse institution", { cause: error });
-        }
-    }
-    async fetchAndParsePlaceDetail(query) {
-        try {
-            const { id, buildingId, floorId, level } = query;
-            const cacheKey = this.placeCacheKey(id, buildingId);
-            const cachedPlace = this.cache.getPlace(cacheKey, this.currentLang);
-            if (cachedPlace != null) {
-                this.logEvent("fetchAndParsePlaceDetail", { cached: "true" });
-                return cachedPlace;
-            }
-            const response = await this.requester.fetchPlaceDetail(this.token, id, buildingId, floorId, level);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const place = new place_1.MVXPlace(responseData);
-            this.cachePlace(place, buildingId);
-            this.logEvent("fetchAndParsePlaceDetail", { cached: "false" });
-            return place;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse place detail", { cause: error });
-        }
-    }
-    async fetchAndParseAnyPlaceDetail(query, authToken) {
-        try {
-            const { id, buildingId, floorId, level } = query;
-            const cacheKey = this.placeCacheKey(id, buildingId);
-            const cachedPlace = this.cache.getPlace(cacheKey, this.currentLang);
-            if (cachedPlace != null) {
-                this.logEvent("fetchAndParseAnyPlaceDetail", { cached: "true" });
-                return cachedPlace;
-            }
-            const response = await this.requester.fetchAnyPlaceDetail(authToken, id, buildingId, floorId, level);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const place = new place_1.MVXPlace(responseData);
-            this.cachePlace(place, buildingId);
-            this.logEvent("fetchAndParseAnyPlaceDetail", { cached: "false" });
-            return place;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse place detail with bearer token", { cause: error });
-        }
-    }
-    /**
-     * Build the cache key for a place lookup. The canonical `mapvxId` is globally
-     * unique, but integrator aliases (`clientId`) may be reused across buildings, so
-     * alias-based keys are namespaced by `buildingId` to prevent aliases from
-     * different venues from colliding in the cache.
-     */
-    placeCacheKey(id, buildingId) {
-        return buildingId != null ? `${id}_${buildingId}` : id;
-    }
-    /**
-     * Cache a place under its globally-unique `mapvxId` and, when present, under its
-     * (possibly non-unique) `clientId` alias namespaced by `buildingId`.
-     */
-    cachePlace(place, buildingId) {
-        this.cache.setPlace(place.mapvxId, place, this.currentLang);
-        if (place.clientId != null) {
-            this.cache.setPlace(this.placeCacheKey(place.clientId, buildingId), place, this.currentLang);
-        }
-    }
-    async fetchAndParseSubPlaces(parentPlaceId) {
-        try {
-            // Check cache first
-            const cachedSubPlaces = this.cache.getSubPlaces(parentPlaceId, this.currentLang);
-            if (cachedSubPlaces != null) {
-                this.logEvent("fetchAndParseSubPlaces", { cached: "true" });
-                return cachedSubPlaces.data;
-            }
-            const response = await this.requester.fetchSubPlaces(parentPlaceId, this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const subPlaces = responseData.map((place) => new place_1.MVXPlace(place));
-            // Cache the result
-            this.cache.setSubPlaces(parentPlaceId, this.currentLang, {
-                timestamp: Date.now(),
-                data: subPlaces,
-            });
-            this.logEvent("fetchAndParseSubPlaces", { cached: "false" });
-            subPlaces.forEach((place) => {
-                if (!this.cache.hasPlace(place.mapvxId, this.currentLang)) {
-                    this.cache.setPlace(place.mapvxId, place, this.currentLang);
-                }
-                if (place.clientId != null && !this.cache.hasPlace(place.clientId, this.currentLang)) {
-                    this.cache.setPlace(place.clientId, place, this.currentLang);
-                }
-            });
-            return subPlaces;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse subplaces", { cause: error });
-        }
-    }
-    async fetchAndParseAnySubPlaces(parentPlaceId, authToken) {
-        try {
-            const response = await this.requester.fetchAnySubPlaces(parentPlaceId, authToken);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const subPlaces = responseData.map((place) => new place_1.MVXPlace(place));
-            this.logEvent("fetchAndParseAnySubPlaces");
-            subPlaces.forEach((place) => {
-                if (!this.cache.hasPlace(place.mapvxId, this.currentLang)) {
-                    this.cache.setPlace(place.mapvxId, place, this.currentLang);
-                }
-                if (place.clientId != null && !this.cache.hasPlace(place.clientId, this.currentLang)) {
-                    this.cache.setPlace(place.clientId, place, this.currentLang);
-                }
-            });
-            return subPlaces;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse any subplaces", { cause: error });
-        }
-    }
-    async fetchAndParseAvailablePlaces() {
-        try {
-            const response = await this.requester.fetchAllowedPlaces(this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const typedResponseData = (await response.json());
-            const data = typedResponseData.map((data) => {
-                return new place_1.MVXPlace(data);
-            });
-            this.logEvent("fetchAndParseAvailablePlaces");
-            data.forEach((place) => {
-                if (!this.cache.hasPlace(place.mapvxId, this.currentLang)) {
-                    this.cache.setPlace(place.mapvxId, place, this.currentLang);
-                }
-                if (place.clientId != null && !this.cache.hasPlace(place.clientId, this.currentLang)) {
-                    this.cache.setPlace(place.clientId, place, this.currentLang);
-                }
-            });
-            return data;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseAvailablePlaces" });
-            throw new Error("Failed to fetch and parse parent places", { cause: error });
-        }
-    }
-    async fetchAndParsePlacesFromInstitution(institutionId, authToken) {
-        try {
-            const response = await this.requester.fetchPlacesFromAnyInstitution(institutionId, authToken);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const typedResponseData = (await response.json());
-            const data = typedResponseData.map((data) => {
-                return new place_1.MVXPlace(data);
-            });
-            this.logEvent("fetchAndParsePlacesFromInstitution");
-            data.forEach((place) => {
-                if (!this.cache.hasPlace(place.mapvxId, this.currentLang)) {
-                    this.cache.setPlace(place.mapvxId, place, this.currentLang);
-                }
-                if (place.clientId != null && !this.cache.hasPlace(place.clientId, this.currentLang)) {
-                    this.cache.setPlace(place.clientId, place, this.currentLang);
-                }
-            });
-            return data;
-        }
-        catch (error) {
-            this.logError(error, {
-                functionName: "fetchAndParsePlacesFromInstitution",
-            });
-            throw new Error("Failed to fetch and parse parent places from institution", { cause: error });
-        }
-    }
-    getCachedPlaces(ids) {
-        const places = [];
-        ids.forEach((id) => {
-            const place = this.cache.getPlace(id, this.currentLang);
-            if (place != null) {
-                places.push(place);
-            }
-        });
-        return places;
-    }
-    /**
-     * Get cached subplaces for a parent place without making additional requests.
-     * @param parentPlaceId The parent place identifier
-     * @returns Array of cached subplaces or undefined if not cached
-     */
-    getCachedSubPlaces(parentPlaceId) {
-        const cachedSubPlaces = this.cache.getSubPlaces(parentPlaceId, this.currentLang);
-        return cachedSubPlaces === null || cachedSubPlaces === void 0 ? void 0 : cachedSubPlaces.data;
-    }
-    async fetchAndParseRoute(config) {
-        try {
-            let destinationId = "";
-            if ("id" in config.finalLocation) {
-                destinationId = config.finalLocation.id;
-            }
-            const cachedResponse = this.cache.getRoute(destinationId);
-            if (cachedResponse != null) {
-                this.logEvent("fetchAndParseRoute", { cached: "true" });
-                this.debugLog("Route cache testing. Found in caché.");
-                return cachedResponse.data;
-            }
-            const response = await this.requester.fetchRoute(config, this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const route = new route_1.MVXRoute(responseData[0]);
-            this.logEvent("fetchAndParseRoute");
-            this.debugLog("Route cache testing. Fetched.");
-            return route;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse route", { cause: error });
-        }
-    }
-    async fetchAndParseRouteV2(config) {
-        try {
-            let destinationId = "";
-            if ("id" in config.finalLocation) {
-                destinationId = config.finalLocation.id;
-            }
-            const cachedResponse = this.cache.getRoute(destinationId);
-            if (cachedResponse != null) {
-                this.logEvent("fetchAndParseRouteV2", { cached: "true" });
-                this.debugLog("Route cache testing. Found in caché.");
-                return cachedResponse.data;
-            }
-            const response = await this.requester.fetchRouteV2(config, this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const route = new route_1.MVXRoute(responseData[0]);
-            this.logEvent("fetchAndParseRouteV2");
-            this.debugLog("Route cache testing. Fetched.");
-            return route;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse route", { cause: error });
-        }
-    }
-    async fetchAndParseLiveRoute(config) {
-        try {
-            // Live routes are always fetched fresh (no cache read) so a moving user
-            // gets an up-to-date path rather than a previously cached one.
-            const response = await this.requester.fetchLiveRoute(config, this.token);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const route = new route_1.MVXRoute(responseData[0]);
-            this.logEvent("fetchAndParseLiveRoute");
-            this.debugLog("Live route fetched.");
-            return route;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse route", { cause: error });
-        }
-    }
-    async fetchAndParseTransport(stopId) {
-        try {
-            const cachedResponse = this.cache.getVehicle(stopId, this.currentLang);
-            if (cachedResponse != null &&
-                (Date.now() - cachedResponse.timestamp < 60 * 1000 ||
-                    cachedResponse.data.routes.length === 0)) {
-                this.logEvent("fetchAndParseTransport", { cached: "true" });
-                return cachedResponse.data;
-            }
-            const response = await this.requester.fetchTransport(this.token, stopId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const typedResponseData = (await response.json());
-            if (typedResponseData.realtimeSchedules.length > 0) {
-                const stopsPromises = typedResponseData.realtimeSchedules.map((e) => this.fetchAndParseStops(stopId, e.vehicleId));
-                const stops = await Promise.all(stopsPromises);
-                if (stops.length > 0) {
-                    typedResponseData.realtimeSchedules.forEach((vehicle) => {
-                        var _a, _b;
-                        vehicle.stops = (_b = (_a = stops.find((e) => e.id == vehicle.vehicleId)) === null || _a === void 0 ? void 0 : _a.places) !== null && _b !== void 0 ? _b : [];
-                    });
-                }
-            }
-            const transport = new transport_1.MVXTransport(typedResponseData);
-            this.cache.setVehicle(stopId, {
-                timestamp: Date.now(),
-                data: transport,
-            }, this.currentLang);
-            this.logEvent("fetchAndParseTransport", { cached: "false" });
-            return transport;
-        }
-        catch (error) {
-            const cachedResponse = this.cache.getVehicle(stopId, this.currentLang);
-            if (cachedResponse != null) {
-                const transport = new transport_1.MVXTransport({
-                    realtimeSchedules: [],
-                    schedules: cachedResponse.data.schedule,
-                });
-                this.logEvent("fetchAndParseTransport", { cached: "true" });
-                return transport;
-            }
-            else {
-                throw new Error("Failed to fetch and parse transport", { cause: error });
-            }
-        }
-    }
-    async fetchAndParseStops(stopId, vehicleId) {
-        try {
-            const cachedResponse = this.cache.getStops(stopId + vehicleId, this.currentLang);
-            if (cachedResponse != null && Date.now() - cachedResponse.timestamp < 60 * 1000) {
-                this.logEvent("fetchAndParseStops", { cached: "true" });
-                return { id: vehicleId, places: cachedResponse.data };
-            }
-            const response = await this.requester.fetchStops(this.token, stopId, vehicleId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const typedResponseData = (await response.json());
-            const data = typedResponseData.map((e) => {
-                return new place_1.MVXPlace(e);
-            });
-            this.cache.setStops(stopId + vehicleId, { timestamp: Date.now(), data }, this.currentLang);
-            this.logEvent("fetchAndParseStops", { cached: "false" });
-            return { id: vehicleId, places: data };
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse stops", { cause: error });
-        }
-    }
-    async fetchAndParseSearchResults(institutionId, input, parentPlaces, origin, lat, lng, floor) {
-        try {
-            const response = await this.requester.fetchSearchResults(institutionId, input, this.token, parentPlaces, origin, lat, lng, floor);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const searchResults = responseData.map((result) => {
-                return new place_1.MVXPlace(result);
-            });
-            return searchResults;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse search results", { cause: error });
-        }
-    }
-    async fetchAndParseSearchPlacesByTags(institutionId, tags, parentPlaces, sort, origin, lat, lng, floor) {
-        try {
-            const response = await this.requester.fetchSearchPlacesByTags(institutionId, tags, this.token, parentPlaces, sort, origin, lat, lng, floor);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const responseData = (await response.json());
-            const places = responseData.map((place) => new place_1.MVXPlace(place));
-            this.logEvent("fetchAndParseSearchPlacesByTags");
-            places.forEach((place) => {
-                if (!this.cache.hasPlace(place.mapvxId, this.currentLang)) {
-                    this.cache.setPlace(place.mapvxId, place, this.currentLang);
-                }
-                if (place.clientId != null && !this.cache.hasPlace(place.clientId, this.currentLang)) {
-                    this.cache.setPlace(place.clientId, place, this.currentLang);
-                }
-            });
-            return places;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse search places by tags", { cause: error });
-        }
-    }
-    async fetchAndParseRoutesFromOrigin(parentPlaceId, fromPlaceId, announceFormat, unitSystem, mode) {
-        try {
-            const response = await this.requester.fetchRoutesForOrigin(this.token, parentPlaceId, fromPlaceId, announceFormat, unitSystem, mode);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const { routes, accessibleRoutes } = (await response.json());
-            Object.entries(routes).forEach(([destinationId, routeResponse]) => {
-                const route = new route_1.MVXRoute(routeResponse[0]);
-                this.cache.setRoute(destinationId, {
-                    timestamp: Date.now(),
-                    data: route,
-                });
-            });
-            Object.entries(accessibleRoutes).forEach(([destinationId, routeResponse]) => {
-                const route = new route_1.MVXRoute(routeResponse[0]);
-                this.cache.setAccessibleRoute(destinationId, {
-                    timestamp: Date.now(),
-                    data: route,
-                });
-            });
-            this.debugLog("Route cache testing. Cache populated!");
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse routes from origin results", { cause: error });
-        }
-    }
-    async fetchAndParseCacheTimestamp(parentPlaceId) {
-        try {
-            const response = await this.requester.fetchCacheTimestamp(this.token, parentPlaceId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const { lastUpdate } = (await response.json());
-            return lastUpdate;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse cache timestamp", { cause: error });
-        }
-    }
-    cleanRoutesCache() {
-        this.cache.cleanRoutesCache();
-        this.cache.cleanAccessibleRoutesCache();
-    }
-    async fetchAndParseConfiguration(placeId, product) {
-        try {
-            // Check cache first
-            const cachedConfig = this.cache.getConfiguration(placeId || "default", product || "default", this.currentLang);
-            if (cachedConfig != null) {
-                this.logEvent("fetchAndParseConfiguration", { cached: "true" });
-                return cachedConfig.data;
-            }
-            const response = await this.requester.fetchConfiguration(this.token, placeId, product);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const config = (await response.json());
-            // Cache the result
-            this.cache.setConfiguration(placeId || "default", product || "default", this.currentLang, {
-                timestamp: Date.now(),
-                data: config,
-            });
-            this.logEvent("fetchAndParseConfiguration", { cached: "false" });
-            return config;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseConfiguration" });
-            throw new Error("Failed to fetch and parse configuration", { cause: error });
-        }
-    }
-    /**
-     * Fetches the campaigns for a maps-group (totem screensaver playlist). Returns them
-     * verbatim — no status/date/schedule filtering, that is the consumer's decision.
-     * `placeId` is the maps-group firebase id; `kioskId` optionally narrows to a totem.
-     * Not cached (campaigns change; the totem keeps its own short-lived cache).
-     */
-    async fetchAndParseCampaigns(placeId, kioskId) {
-        try {
-            const response = await this.requester.fetchCampaigns(this.token, placeId, kioskId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const raw = (await response.json());
-            // A non-array body is a contract break (a `{ campaigns: [...] }` wrapper, an HTML
-            // error page served with a 200). Degrading to an empty playlist keeps the totem
-            // running, but it must not look like a successful empty fetch — without this
-            // warning the screensaver just goes blank with nothing to diagnose.
-            if (!Array.isArray(raw)) {
-                this.logWarning(new Error("Campaigns response body was not an array"), {
-                    functionName: "fetchAndParseCampaigns",
-                    receivedType: raw === null ? "null" : typeof raw,
-                });
-            }
-            const campaigns = (Array.isArray(raw) ? raw : []).map((item) => new campaign_1.Campaign(item));
-            this.logEvent("fetchAndParseCampaigns", { count: String(campaigns.length) });
-            return campaigns;
-        }
-        catch (error) {
-            this.logError(error, { functionName: "fetchAndParseCampaigns" });
-            throw new Error("Failed to fetch and parse campaigns", { cause: error });
-        }
-    }
-    async fetchAndParseCategories(placeId) {
-        try {
-            // Check cache first
-            const cachedCategories = this.cache.getCategories(placeId || "default", this.currentLang);
-            if (cachedCategories != null) {
-                this.logEvent("fetchAndParseCategories", { cached: "true" });
-                return cachedCategories.data;
-            }
-            const response = await this.requester.fetchCategories(this.token, placeId);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const categories = (await response.json());
-            // Cache the result
-            this.cache.setCategories(placeId || "default", this.currentLang, {
-                timestamp: Date.now(),
-                data: categories,
-            });
-            this.logEvent("fetchAndParseCategories", { cached: "false" });
-            return categories;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse categories", { cause: error });
-        }
-    }
-    async fetchAndParseCssCustomization(type) {
-        try {
-            const response = await this.requester.fetchCssCustomization(this.token, type);
-            if (!response.ok) {
-                const errorBody = await response.json();
-                throw new Error(`Fetch failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-            }
-            const cssCustomization = (await response.json());
-            return cssCustomization;
-        }
-        catch (error) {
-            throw new Error("Failed to fetch and parse css customization", { cause: error });
-        }
-    }
-    async postAndParseHealthPing(healthPingId, placeId, totemId, status) {
-        const response = await this.requester.postHealth(this.token, healthPingId, placeId, totemId, status);
-        if (!response.ok) {
-            const errorBody = await response.json();
-            throw new Error(`Post failed with status ${response.status}: ${extractErrorMessage(errorBody)}`);
-        }
-        const data = (await response.json());
-        return data;
-    }
-}
-exports.Repository = Repository;
-//# sourceMappingURL=repository.js.map