keepkey-vault-sdk 1.2.4 → 1.2.6

package/dist/src/fetch.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Universal Fetch Transport Layer
+ *
+ * Runtime-agnostic fetch implementation that works in:
+ * - Browser/WebView (Tauri)
+ * - Node 18+ (native fetch)
+ * - Node <18 (with injected fetch)
+ * - React Native (with injected fetch)
+ */
+export type FetchLike = typeof fetch;
+/**
+ * HTTP Error with status code and response body
+ */
+export declare class HttpError extends Error {
+    status: number;
+    bodyText?: string | undefined;
+    response?: Response | undefined;
+    constructor(message: string, status: number, bodyText?: string | undefined, response?: Response | undefined);
+}
+/**
+ * Resolve fetch implementation from environment or injection
+ */
+export declare function resolveFetch(fetchImpl?: FetchLike): FetchLike;
+/**
+ * Create a fetch wrapper with error handling
+ */
+export declare function createFetchWrapper(fetchImpl?: FetchLike): (url: URL | RequestInfo, init?: RequestInit) => Promise<Response>;
+/**
+ * Environment detection utilities
+ */
+export declare const environment: {
+    /**
+     * Check if running in browser environment
+     */
+    isBrowser: boolean;
+    /**
+     * Check if running in Node.js environment
+     */
+    isNode: boolean;
+    /**
+     * Check if native fetch is available
+     */
+    hasNativeFetch: boolean;
+    /**
+     * Get environment name for debugging
+     */
+    readonly name: string;
+};
+/**
+ * Get appropriate fetch for current environment
+ */
+export declare function getEnvironmentFetch(): FetchLike;

package/dist/src/fetch.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Universal Fetch Transport Layer
+ *
+ * Runtime-agnostic fetch implementation that works in:
+ * - Browser/WebView (Tauri)
+ * - Node 18+ (native fetch)
+ * - Node <18 (with injected fetch)
+ * - React Native (with injected fetch)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvironmentFetch = exports.environment = exports.createFetchWrapper = exports.resolveFetch = exports.HttpError = void 0;
+/**
+ * HTTP Error with status code and response body
+ */
+class HttpError extends Error {
+    constructor(message, status, bodyText, response) {
+        super(message);
+        this.status = status;
+        this.bodyText = bodyText;
+        this.response = response;
+        this.name = 'HttpError';
+    }
+}
+exports.HttpError = HttpError;
+/**
+ * Resolve fetch implementation from environment or injection
+ */
+function resolveFetch(fetchImpl) {
+    const resolved = fetchImpl ?? globalThis.fetch;
+    if (!resolved || typeof resolved !== 'function') {
+        throw new Error('No fetch implementation found. ' +
+            'Provide `fetch` in SDK options (e.g. undici for Node<18, polyfill for older browsers).');
+    }
+    return resolved.bind(globalThis);
+}
+exports.resolveFetch = resolveFetch;
+/**
+ * Create a fetch wrapper with error handling
+ */
+function createFetchWrapper(fetchImpl) {
+    const fetchFn = resolveFetch(fetchImpl);
+    return async (url, init) => {
+        try {
+            const response = await fetchFn(url, init);
+            // Don't throw on HTTP errors here - let the caller decide
+            // This matches the native fetch behavior
+            return response;
+        }
+        catch (error) {
+            // Network/connection errors
+            if (error instanceof Error) {
+                throw new HttpError(`Network error: ${error.message}`, 0, undefined);
+            }
+            throw error;
+        }
+    };
+}
+exports.createFetchWrapper = createFetchWrapper;
+/**
+ * Environment detection utilities
+ */
+exports.environment = {
+    /**
+     * Check if running in browser environment
+     */
+    isBrowser: typeof window !== 'undefined' && typeof window.fetch === 'function',
+    /**
+     * Check if running in Node.js environment
+     */
+    isNode: typeof process !== 'undefined' && process.versions?.node !== undefined,
+    /**
+     * Check if native fetch is available
+     */
+    hasNativeFetch: typeof globalThis !== 'undefined' && typeof globalThis.fetch === 'function',
+    /**
+     * Get environment name for debugging
+     */
+    get name() {
+        if (this.isBrowser)
+            return 'browser';
+        if (this.isNode)
+            return 'node';
+        return 'unknown';
+    },
+};
+/**
+ * Get appropriate fetch for current environment
+ */
+function getEnvironmentFetch() {
+    if (exports.environment.hasNativeFetch) {
+        return globalThis.fetch.bind(globalThis);
+    }
+    // This should rarely happen in modern environments
+    throw new Error(`No native fetch found in ${exports.environment.name} environment. ` +
+        'Please provide a fetch implementation in SDK options.');
+}
+exports.getEnvironmentFetch = getEnvironmentFetch;

package/dist/src/index.d.ts

@@ -37,4 +37,6 @@ export type { DeviceStatus } from './device-status';
 export { DeviceStatusChecker } from './device-status';
 export type { SDKConfigurationParameters } from './sdk-config';
 export { createSDKConfig, createSDKConfigWithVersion, SDKConfiguration } from './sdk-config';
+export type { FetchLike, HttpError } from './fetch';
+export { createFetchWrapper, environment, getEnvironmentFetch, resolveFetch } from './fetch';
 export type { Configuration, ConfigurationParameters } from './generated/v2/runtime';

package/dist/src/index.js

@@ -41,7 +41,7 @@ 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 });
-exports.SDKConfiguration = exports.createSDKConfigWithVersion = exports.createSDKConfig = exports.DeviceStatusChecker = exports.VersionDetector = exports.SpecLoader = exports.VersionRouter = exports.KeepKeySdk = void 0;
+exports.resolveFetch = exports.getEnvironmentFetch = exports.environment = exports.createFetchWrapper = exports.SDKConfiguration = exports.createSDKConfigWithVersion = exports.createSDKConfig = exports.DeviceStatusChecker = exports.VersionDetector = exports.SpecLoader = exports.VersionRouter = exports.KeepKeySdk = void 0;
 var KeepKeySdk_1 = require("./KeepKeySdk");
 Object.defineProperty(exports, "KeepKeySdk", { enumerable: true, get: function () { return KeepKeySdk_1.KeepKeySdk; } });
 // Export generated API (v2 by default for backward compatibility)
@@ -59,3 +59,8 @@ var sdk_config_1 = require("./sdk-config");
 Object.defineProperty(exports, "createSDKConfig", { enumerable: true, get: function () { return sdk_config_1.createSDKConfig; } });
 Object.defineProperty(exports, "createSDKConfigWithVersion", { enumerable: true, get: function () { return sdk_config_1.createSDKConfigWithVersion; } });
 Object.defineProperty(exports, "SDKConfiguration", { enumerable: true, get: function () { return sdk_config_1.SDKConfiguration; } });
+var fetch_1 = require("./fetch");
+Object.defineProperty(exports, "createFetchWrapper", { enumerable: true, get: function () { return fetch_1.createFetchWrapper; } });
+Object.defineProperty(exports, "environment", { enumerable: true, get: function () { return fetch_1.environment; } });
+Object.defineProperty(exports, "getEnvironmentFetch", { enumerable: true, get: function () { return fetch_1.getEnvironmentFetch; } });
+Object.defineProperty(exports, "resolveFetch", { enumerable: true, get: function () { return fetch_1.resolveFetch; } });

package/dist/src/sdk-config.d.ts

@@ -4,12 +4,18 @@
  * Extends the generated Configuration with automatic API version detection
  * and intelligent routing between v1 and v2 APIs.
  */
+import type { FetchLike } from './fetch';
 import type { ConfigurationParameters } from './generated/v2/runtime';
 import { Configuration } from './generated/v2/runtime';
 import { VersionRouter } from './middleware/version-router';
 import type { ApiVersionInfo } from './version-detector';
 import { VersionDetector } from './version-detector';
 export interface SDKConfigurationParameters extends ConfigurationParameters {
+    /**
+     * Optional fetch implementation for environments without native fetch
+     * (e.g. Node.js <18, React Native)
+     */
+    fetch?: FetchLike;
     /**
      * Enable automatic version detection via /api/health endpoint
      * @default true

package/dist/src/sdk-config.js

@@ -7,15 +7,24 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSDKConfigWithVersion = exports.createSDKConfig = exports.SDKConfiguration = void 0;
+const fetch_1 = require("./fetch");
 const runtime_1 = require("./generated/v2/runtime");
 const version_router_1 = require("./middleware/version-router");
 const version_detector_1 = require("./version-detector");
 class SDKConfiguration extends runtime_1.Configuration {
     constructor(params = {}) {
-        super(params);
+        // Create universal fetch wrapper
+        const fetchImpl = params.fetch || (0, fetch_1.getEnvironmentFetch)();
+        const fetchWrapper = (0, fetch_1.createFetchWrapper)(fetchImpl);
+        // Configure with wrapped fetch
+        super({
+            ...params,
+            fetchApi: fetchWrapper,
+        });
         this.autoDetectVersion = params.autoDetectVersion !== false; // Default to true
         this.manualApiVersion = params.apiVersion;
-        this.versionDetector = params.versionDetector || new version_detector_1.VersionDetector(this.basePath);
+        this.versionDetector =
+            params.versionDetector || new version_detector_1.VersionDetector(this.basePath, fetchWrapper);
     }
     /**
      * Initialize version detection.

package/dist/src/version-detector.d.ts

@@ -12,7 +12,8 @@ export interface ApiVersionInfo {
 export declare class VersionDetector {
     private basePath;
     private cachedVersion;
-    constructor(basePath: string);
+    private fetchFn;
+    constructor(basePath: string, fetchFn?: typeof fetch);
     /**
      * Detects API version by fetching /spec/swagger.json and reading info.version.
      * Returns version info or defaults to v1 if detection fails.

package/dist/src/version-detector.js

@@ -8,9 +8,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionDetector = void 0;
 class VersionDetector {
-    constructor(basePath) {
+    constructor(basePath, fetchFn) {
         this.cachedVersion = null;
         this.basePath = basePath.replace(/\/+$/, ''); // Remove trailing slashes
+        this.fetchFn = fetchFn || globalThis.fetch;
     }
     /**
      * Detects API version by fetching /spec/swagger.json and reading info.version.
@@ -23,7 +24,7 @@ class VersionDetector {
             return this.cachedVersion;
         }
         try {
-            const response = await fetch(`${this.basePath}/spec/swagger.json`, {
+            const response = await this.fetchFn(`${this.basePath}/spec/swagger.json`, {
                 method: 'GET',
                 headers: {
                     Accept: 'application/json',