@nascentdigital/funnel-core 4.4.4

package/dist/app/AppConfig.d.ts

@@ -0,0 +1,41 @@
+import { type Page } from '../schema/Page';
+import { PartialBy, Timestamp } from '../types';
+import { BrandConfig } from './BrandConfig';
+import { UIConfig } from './UIConfig';
+export type AppConfig<TBrand extends string = string, TBrandType extends string = string, TRegion extends string = string> = {
+    private: boolean;
+    baseUrl: string;
+    timezone: Timestamp.Timezone;
+    /**
+     * Determines the types of pages that will be fetched when pulling content (either `published` or
+     * `draft` - where `published` is the default).
+     */
+    version: Exclude<Page.State, 'unpublished'>;
+    brands: Record<TBrand, BrandConfig<TBrandType, TRegion>>;
+    recaptcha: AppConfig.RecaptchaConfig;
+    sso: AppConfig.SsoConfig;
+    ui: UIConfig;
+    accessible: boolean;
+    nativeYoutube?: boolean;
+};
+export declare namespace AppConfig {
+    type RecaptchaConfig = {
+        siteKey: string;
+    };
+    type SsoConfig = {
+        mode: SsoConfig.Mode;
+        googleClientId: string;
+    };
+    namespace SsoConfig {
+        type Mode = 'email' | 'google';
+        namespace Mode {
+            function coerce(value: string | undefined, fallback: Mode): SsoConfig.Mode;
+        }
+    }
+    function get<TBrand extends string = string, TBrandType extends string = string, TRegion extends string = string>(): Readonly<AppConfig<TBrand, TBrandType, TRegion>>;
+    function set<TBrand extends string = string, TBrandType extends string = string, TRegion extends string = string>(value: PartialBy<AppConfig<TBrand, TBrandType, TRegion>, 'private' | 'accessible'>): void;
+    function brand<TBrand extends string = string>(): TBrand;
+    function brandConfig<TBrand extends string = string, TBrandType extends string = string, TRegion extends string = string>(): Readonly<BrandConfig<TBrandType, TRegion>>;
+    function ssoConfig(): SsoConfig;
+    function uiConfig(): UIConfig;
+}

package/dist/app/AppConfig.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppConfig = void 0;
+const errors_1 = require("../errors");
+// extension
+var AppConfig;
+(function (AppConfig) {
+    let SsoConfig;
+    (function (SsoConfig) {
+        let Mode;
+        (function (Mode) {
+            // helpers
+            function coerce(value, fallback) {
+                var _a;
+                const normalizedValue = (_a = value === null || value === void 0 ? void 0 : value.trim().toLowerCase()) !== null && _a !== void 0 ? _a : '';
+                switch (normalizedValue) {
+                    case 'email':
+                    case 'google':
+                        return normalizedValue;
+                    default:
+                        return fallback;
+                }
+            }
+            Mode.coerce = coerce;
+        })(Mode = SsoConfig.Mode || (SsoConfig.Mode = {}));
+    })(SsoConfig = AppConfig.SsoConfig || (AppConfig.SsoConfig = {}));
+    // methods
+    function get() {
+        // throw if config isn't bound
+        if (!config) {
+            throw new errors_1.IllegalStateError('Attempt to access AppConfig before first call to AppConfig.set()');
+        }
+        return config;
+    }
+    AppConfig.get = get;
+    function set(value) {
+        const defaults = {
+            private: false,
+            version: 'published',
+            accessible: true
+        };
+        config = Object.assign(Object.assign(Object.assign({}, defaults), (config !== null && config !== void 0 ? config : {})), value);
+    }
+    AppConfig.set = set;
+    function brand() {
+        // throw if the brand isn't defined
+        const brand = process.env.FUNNEL_BRAND || process.env.NEXT_PUBLIC_BRAND;
+        if (!brand) {
+            throw new errors_1.IllegalStateError('Unable to resolve $FUNNEL_BRAND');
+        }
+        // return brand
+        return brand;
+    }
+    AppConfig.brand = brand;
+    function brandConfig() {
+        // throw if brands are missing
+        const { brands } = get();
+        if (!brands) {
+            throw new errors_1.IllegalStateError('No brands defined in AppConfig');
+        }
+        // throw if config is missing
+        const brandId = brand();
+        const brandConfig = brands[brandId];
+        if (!brandConfig) {
+            throw new errors_1.IllegalStateError(`No BrandConfig set for brand "${brandId}"`);
+        }
+        // return config
+        return brandConfig;
+    }
+    AppConfig.brandConfig = brandConfig;
+    function ssoConfig() {
+        // get config
+        const { sso } = get();
+        if (!sso) {
+            throw new errors_1.IllegalStateError('No SsoConfig is defined for this site');
+        }
+        // return config
+        return sso;
+    }
+    AppConfig.ssoConfig = ssoConfig;
+    function uiConfig() {
+        // get config
+        const { ui } = get();
+        if (!ui) {
+            throw new errors_1.IllegalStateError('No UIConfig is defined for this site');
+        }
+        // return config
+        return ui;
+    }
+    AppConfig.uiConfig = uiConfig;
+})(AppConfig || (exports.AppConfig = AppConfig = {}));
+// global context
+let config = undefined;

package/dist/app/BrandConfig.d.ts

@@ -0,0 +1,13 @@
+import { FeaturesConfig } from './FeaturesConfig';
+import { RegionsConfig } from './RegionsConfig';
+export type BrandConfig<TBrandType extends string = string, TRegion extends string = string> = {
+    type: TBrandType;
+    name: string;
+    regionalization: RegionsConfig<TRegion>;
+    features?: FeaturesConfig;
+};
+export declare namespace BrandConfig {
+    type WithId<TBrandType extends string = string, TRegion extends string = string> = BrandConfig<TBrandType, TRegion> & {
+        id: string;
+    };
+}

package/dist/app/BrandConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app/FeaturesConfig.d.ts

@@ -0,0 +1,6 @@
+export type FeaturesConfig = {
+    [F in FeaturesConfig.Features]?: string | boolean | number;
+};
+export declare namespace FeaturesConfig {
+    type Features = 'mobileContactCTAVisible';
+}

package/dist/app/FeaturesConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app/RegionsConfig.d.ts

@@ -0,0 +1,43 @@
+import { Language, Locale } from '../regionalization';
+export type RegionsConfig<TRegion extends string = string> = {
+    regions: Record<TRegion, RegionsConfig.RegionConfig>;
+    fallback: TRegion;
+    urlTruncation: RegionsConfig.UrlTruncation;
+    mergedRoutes?: boolean;
+};
+export declare namespace RegionsConfig {
+    type RegionConfig = {
+        name: string;
+        languages: Language[];
+        defaultLanguage?: Language;
+    };
+    namespace RegionConfig {
+        type WithId<TRegion extends string = string> = RegionConfig & {
+            id: TRegion;
+        };
+    }
+    type UrlTruncation = 'none' | 'full' | 'partial';
+    type Type = 'language-only' | 'region-only' | 'locale-composite' | 'locale-split';
+    function getRegions<TRegion extends string = string>(config: RegionsConfig<TRegion>): RegionConfig.WithId<TRegion>[];
+    function getType(regionalization: RegionsConfig): Type;
+    function tryParse<TRegion extends string = string>(regionalization: RegionsConfig, value: string | undefined): TRegion | undefined;
+    function parse<TRegion extends string = string>(regionalization: RegionsConfig, value: string | undefined): TRegion;
+    function getRegionConfig<TRegion extends string = string>(regionalization: RegionsConfig, region: TRegion): RegionConfig;
+    function getLocales<TRegion extends string = string>(regionalization: RegionsConfig): [TRegion, Language][];
+    function getLanguages(regionalization: RegionsConfig): Language[];
+    /**
+     * Given a config for all regions, return the default region. If the default region is set through cookies, we use
+     * that. Otherwise, we use the fallback.
+     */
+    function getDefaultRegion(regionalization: RegionsConfig, inferredLocale?: Partial<Locale>): string;
+    /**
+     * Given a config for a specific region, return the default language for that region. If the default language
+     * is set through cookies, we use hat. Otherwise, if set we use the default language for that region. Otherwise,
+     * we use the first language available.
+     */
+    function getDefaultLanguageForRegion(config: RegionConfig, inferredLocale: Partial<Locale>): Language;
+    /**
+     * Given the config for all regions, return the default language for the default region.
+     */
+    function getDefaultLanguage(regionalization: RegionsConfig, inferredLocale?: Partial<Locale>): Language;
+}

package/dist/app/RegionsConfig.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegionsConfig = void 0;
+const errors_1 = require("../errors");
+const utils_1 = require("../utils");
+// extension
+var RegionsConfig;
+(function (RegionsConfig) {
+    // methods
+    function getRegions(config) {
+        return Object.entries(config.regions).map(([id, config]) => (Object.assign({ id: id }, config)));
+    }
+    RegionsConfig.getRegions = getRegions;
+    function getType(regionalization) {
+        const regions = Object.entries(regionalization.regions);
+        if (regions.length === 0) {
+            throw new errors_1.IllegalStateError('RegionsConfig must have at least one region');
+        }
+        // handle case where there is just a single region (languages only)
+        if (regions.length === 1) {
+            return 'language-only';
+        }
+        // or, route by regions only if there's just a single language
+        const languages = RegionsConfig.getLanguages(regionalization);
+        if (languages.length === 1) {
+            return 'region-only';
+        }
+        // or create composite local if specified
+        else if (regionalization.mergedRoutes) {
+            return 'locale-composite';
+        }
+        // otherwise, use split locale
+        else {
+            return 'locale-split';
+        }
+    }
+    RegionsConfig.getType = getType;
+    function tryParse(regionalization, value) {
+        // skip if there's no value
+        if (!value) {
+            return undefined;
+        }
+        // search for match
+        const normalizedValue = value.trim().toLowerCase();
+        return Object.keys(regionalization.regions)
+            .find(region => region.toLowerCase() === normalizedValue);
+    }
+    RegionsConfig.tryParse = tryParse;
+    function parse(regionalization, value) {
+        // throw if the value can't be parsed
+        const region = tryParse(regionalization, value);
+        if (!region) {
+            throw new errors_1.ArgumentError(`Invalid region: ${region}`, 'region');
+        }
+        // return region
+        return region;
+    }
+    RegionsConfig.parse = parse;
+    function getRegionConfig(regionalization, region) {
+        // get region config (or throw)
+        const config = regionalization.regions[region];
+        if (!config) {
+            throw new errors_1.InvalidOperationError(`Attempt to use unconfigured region: ${region}`);
+        }
+        // return config
+        return config;
+    }
+    RegionsConfig.getRegionConfig = getRegionConfig;
+    function getLocales(regionalization) {
+        return Object.entries(regionalization.regions)
+            .flatMap(([region, config]) => config === null || config === void 0 ? void 0 : config.languages.map(language => ([region, language])))
+            .filter(utils_1.Value.isDefined);
+    }
+    RegionsConfig.getLocales = getLocales;
+    function getLanguages(regionalization) {
+        return Object.values(regionalization.regions).reduce((languages, regionConfig) => {
+            // add missing languages
+            if (regionConfig) {
+                languages.push(...regionConfig.languages.filter((l) => !languages.includes(l)));
+            }
+            // keep reducing
+            return languages;
+        }, []);
+    }
+    RegionsConfig.getLanguages = getLanguages;
+    /**
+     * Given a config for all regions, return the default region. If the default region is set through cookies, we use
+     * that. Otherwise, we use the fallback.
+     */
+    function getDefaultRegion(regionalization, inferredLocale = {}) {
+        var _a;
+        return (_a = inferredLocale.region) !== null && _a !== void 0 ? _a : regionalization.fallback;
+    }
+    RegionsConfig.getDefaultRegion = getDefaultRegion;
+    /**
+     * Given a config for a specific region, return the default language for that region. If the default language
+     * is set through cookies, we use hat. Otherwise, if set we use the default language for that region. Otherwise,
+     * we use the first language available.
+     */
+    function getDefaultLanguageForRegion(config, inferredLocale) {
+        var _a, _b;
+        return (_b = (_a = inferredLocale.language) !== null && _a !== void 0 ? _a : config.defaultLanguage) !== null && _b !== void 0 ? _b : config.languages[0];
+    }
+    RegionsConfig.getDefaultLanguageForRegion = getDefaultLanguageForRegion;
+    /**
+     * Given the config for all regions, return the default language for the default region.
+     */
+    function getDefaultLanguage(regionalization, inferredLocale = {}) {
+        const config = getRegionConfig(regionalization, regionalization.fallback);
+        return getDefaultLanguageForRegion(config, inferredLocale);
+    }
+    RegionsConfig.getDefaultLanguage = getDefaultLanguage;
+})(RegionsConfig || (exports.RegionsConfig = RegionsConfig = {}));

package/dist/app/UIConfig.d.ts

@@ -0,0 +1,4 @@
+import { Duration } from '../utils';
+export type UIConfig = {
+    carouselInterval?: Duration;
+};

package/dist/app/UIConfig.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/app/index.d.ts

@@ -0,0 +1,5 @@
+export * from './AppConfig';
+export * from './BrandConfig';
+export * from './RegionsConfig';
+export * from './UIConfig';
+export * from './FeaturesConfig';

package/dist/app/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AppConfig"), exports);
+__exportStar(require("./BrandConfig"), exports);
+__exportStar(require("./RegionsConfig"), exports);
+__exportStar(require("./UIConfig"), exports);
+__exportStar(require("./FeaturesConfig"), exports);

package/dist/consent/ConsentCategory.d.ts

@@ -0,0 +1,12 @@
+export type ConsentCategory = 'necessary' | 'functionality' | 'security' | 'analytics' | 'advertisement';
+export declare namespace ConsentCategory {
+    const values: ReadonlyArray<ConsentCategory>;
+    function filter(value: any): value is ConsentCategory;
+    type Choice = {
+        category: ConsentCategory;
+        accepted: boolean;
+    };
+    namespace Choice {
+        function filter(value: any): value is Choice;
+    }
+}

package/dist/consent/ConsentCategory.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentCategory = void 0;
+// extension
+var ConsentCategory;
+(function (ConsentCategory) {
+    // values
+    ConsentCategory.values = [
+        'necessary', 'functionality', 'security', 'analytics', 'advertisement'
+    ];
+    // helpers
+    function filter(value) {
+        return !!value
+            && typeof value === 'string'
+            && ConsentCategory.values.includes(value);
+    }
+    ConsentCategory.filter = filter;
+    let Choice;
+    (function (Choice) {
+        function filter(value) {
+            return !!value
+                && typeof value === 'object'
+                && 'category' in value && ConsentCategory.filter(value.category)
+                && 'accepted' in value && typeof value.accepted === 'boolean';
+        }
+        Choice.filter = filter;
+    })(Choice = ConsentCategory.Choice || (ConsentCategory.Choice = {}));
+})(ConsentCategory || (exports.ConsentCategory = ConsentCategory = {}));

package/dist/consent/ConsentService.d.ts

@@ -0,0 +1,15 @@
+import { ConsentCategory } from './ConsentCategory';
+export type ConsentService = 'functionality_storage' | 'personalization_storage' | 'security_storage' | 'analytics_storage' | 'ad_storage' | 'ad_user_data' | 'ad_personalization';
+export declare namespace ConsentService {
+    const groupedValues: Readonly<Record<ConsentCategory, ReadonlyArray<ConsentService>>>;
+    const values: ReadonlyArray<ConsentService>;
+    function filter(value: any): value is ConsentService;
+    type Choice = {
+        category: ConsentCategory;
+        service: ConsentService;
+        accepted: boolean;
+    };
+    namespace Choice {
+        function filter(value: any): value is Choice;
+    }
+}

package/dist/consent/ConsentService.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsentService = void 0;
+const ConsentCategory_1 = require("./ConsentCategory");
+// extension
+var ConsentService;
+(function (ConsentService) {
+    // values
+    ConsentService.groupedValues = {
+        necessary: [],
+        functionality: ['functionality_storage', 'personalization_storage'],
+        security: ['security_storage'],
+        analytics: ['analytics_storage'],
+        advertisement: ['ad_storage', 'ad_user_data', 'ad_personalization']
+    };
+    ConsentService.values = [
+        'functionality_storage', 'personalization_storage',
+        'security_storage',
+        'analytics_storage',
+        'ad_storage', 'ad_user_data', 'ad_personalization'
+    ];
+    // helpers
+    function filter(value) {
+        return !!value
+            && typeof value === 'string'
+            && ConsentService.values.includes(value);
+    }
+    ConsentService.filter = filter;
+    let Choice;
+    (function (Choice) {
+        function filter(value) {
+            return ConsentCategory_1.ConsentCategory.Choice.filter(value)
+                && 'service' in value && ConsentService.filter(value.service);
+        }
+        Choice.filter = filter;
+    })(Choice = ConsentService.Choice || (ConsentService.Choice = {}));
+})(ConsentService || (exports.ConsentService = ConsentService = {}));

package/dist/consent/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ConsentCategory';
+export * from './ConsentService';

package/dist/consent/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ConsentCategory"), exports);
+__exportStar(require("./ConsentService"), exports);

package/dist/errors/IsometricError.d.ts

@@ -0,0 +1,19 @@
+import { IsometricErrorModule } from './IsometricErrorModule';
+import { SerializedIsometricError } from './SerializedIsometricError';
+export declare class IsometricError extends Error {
+    readonly moduleId: IsometricErrorModule.Id;
+    readonly cause?: Error | undefined;
+    constructor(args: IsometricError.ConstructorArgs);
+    serialize(): SerializedIsometricError;
+}
+export declare namespace IsometricError {
+    type ConstructorArgs = {
+        moduleId: IsometricErrorModule.Id;
+        message: string;
+        cause?: Error | undefined;
+        trace?: ((...args: any) => any) | undefined;
+    };
+    namespace ConstructorArgs {
+        type WithoutModuleId = Omit<ConstructorArgs, 'moduleId'>;
+    }
+}

package/dist/errors/IsometricError.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsometricError = void 0;
+// class
+class IsometricError extends Error {
+    constructor(args) {
+        // construct base
+        super(args.message);
+        // link prototype chain
+        Object.setPrototypeOf(this, new.target.prototype);
+        // bind properties
+        const object = this;
+        this.name = object.constructor.name;
+        this.moduleId = args.moduleId;
+        this.cause = args.cause;
+        // bind stack trace (if provided)
+        if (args.trace) {
+            Error.captureStackTrace(this, args.trace);
+        }
+    }
+    serialize() {
+        const { moduleId, name, message } = this;
+        return {
+            moduleId,
+            name,
+            message
+        };
+    }
+}
+exports.IsometricError = IsometricError;

package/dist/errors/IsometricErrorModule.d.ts

@@ -0,0 +1,11 @@
+import { Tagged } from 'type-fest';
+import { IsometricError } from './IsometricError';
+import { SerializedIsometricError } from './SerializedIsometricError';
+export interface IsometricErrorModule {
+    readonly id: IsometricErrorModule.Id;
+    deserialize(data: SerializedIsometricError): IsometricError | undefined;
+}
+export declare namespace IsometricErrorModule {
+    type Id = Tagged<string, 'nascent.IsometricErrorModule.Id'>;
+    type Constructor = new () => IsometricErrorModule;
+}

package/dist/errors/IsometricErrorModule.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errors/IsometricErrorUtils.d.ts

@@ -0,0 +1,9 @@
+import type { Callback } from '../types';
+import { IsometricError } from './IsometricError';
+import { IsometricErrorModule } from './IsometricErrorModule';
+export declare namespace IsometricErrorUtils {
+    function registerModule(ModuleClass: IsometricErrorModule.Constructor): void;
+    function coerceError(error: any): IsometricError;
+    function deserializeError(data: any): IsometricError | undefined;
+    function checkResponse(response: Response, onError?: Callback<IsometricError>): Promise<void>;
+}

package/dist/errors/IsometricErrorUtils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsometricErrorUtils = void 0;
+const Value_1 = require("../utils/Value");
+const api_1 = require("./api");
+const IsometricError_1 = require("./IsometricError");
+const SerializedIsometricError_1 = require("./SerializedIsometricError");
+// namespace
+var IsometricErrorUtils;
+(function (IsometricErrorUtils) {
+    // constants
+    const modules = new Map();
+    // methods
+    function registerModule(ModuleClass) {
+        const module = new ModuleClass();
+        modules.set(module.id, module);
+    }
+    IsometricErrorUtils.registerModule = registerModule;
+    function coerceError(error) {
+        // skip if already isometric
+        if (error instanceof IsometricError_1.IsometricError) {
+            return error;
+        }
+        // or wrap error
+        else if (error instanceof Error) {
+            return new api_1.ServerError(error.message);
+        }
+        // or create generic error
+        else {
+            return new api_1.ServerError();
+        }
+    }
+    IsometricErrorUtils.coerceError = coerceError;
+    function deserializeError(data) {
+        // skip if it's not isometric
+        if (!SerializedIsometricError_1.SerializedIsometricError.filter(data)) {
+            console.debug('[IsometricErrorUtils/deserialize] data is not an error', data);
+            return undefined;
+        }
+        // or skip if there's no registered module
+        const module = modules.get(data.moduleId);
+        if (!module) {
+            console.debug('[IsometricErrorUtils/deserialize] module not found', data.moduleId);
+            return undefined;
+        }
+        const error = module.deserialize(data);
+        console.debug('[IsometricErrorUtils/deserialize] parsed error', { module, error });
+        // deserialize
+        return error;
+    }
+    IsometricErrorUtils.deserializeError = deserializeError;
+    async function checkResponse(response, onError) {
+        var _a;
+        // skip if response is good
+        if (response.ok) {
+            return;
+        }
+        const { bodyUsed, headers, type } = response;
+        console.debug('[IsometricErrorUtils] handling error', { type, bodyUsed, headers });
+        // throw network error if the request didn't even go through
+        let error;
+        if (response.type === 'error') {
+            error = new api_1.OfflineError();
+        }
+        // or try to extract from json
+        else {
+            const json = await response.json();
+            console.debug('[IsometricErrorUtils] transforming error', {
+                json,
+                isIso: SerializedIsometricError_1.SerializedIsometricError.filter(json.error)
+            });
+            const { error: errorData } = Value_1.Value.typeOf(json) === 'object'
+                ? json
+                : {};
+            error = (_a = deserializeError(errorData)) !== null && _a !== void 0 ? _a : new api_1.ServerError();
+        }
+        // perform callback (if any)
+        if (onError) {
+            onError(error);
+        }
+        // throw error
+        throw error;
+    }
+    IsometricErrorUtils.checkResponse = checkResponse;
+})(IsometricErrorUtils || (exports.IsometricErrorUtils = IsometricErrorUtils = {}));

package/dist/errors/SerializedIsometricError.d.ts

@@ -0,0 +1,10 @@
+import { JsonObject } from 'type-fest';
+import { IsometricErrorModule } from './IsometricErrorModule';
+export type SerializedIsometricError = JsonObject & {
+    moduleId: IsometricErrorModule.Id;
+    name: string;
+    message: string;
+};
+export declare namespace SerializedIsometricError {
+    function filter(value: any): value is SerializedIsometricError;
+}