@buildonspark/spark-sdk 0.3.4 → 0.3.6

package/dist/chunk-EHKP3Y65.js

@@ -0,0 +1,140 @@
+import {
+  ConnectionManager,
+  NetworkError,
+  SparkWallet,
+  clientEnv
+} from "./chunk-XPHYQ2L6.js";
+
+// src/services/connection/connection.browser.ts
+import {
+  createChannel,
+  FetchTransport,
+  createClientFactory
+} from "nice-grpc-web";
+import { Metadata } from "nice-grpc-common";
+import { retryMiddleware } from "nice-grpc-client-middleware-retry";
+var ConnectionManagerBrowser = class extends ConnectionManager {
+  transport;
+  constructor(config, transport = FetchTransport()) {
+    super(config);
+    this.transport = transport;
+  }
+  async createChannelWithTLS(address, certPath) {
+    try {
+      return createChannel(address, this.transport);
+    } catch (error) {
+      console.error("Channel creation error:", error);
+      throw new NetworkError(
+        "Failed to create channel",
+        {
+          url: address,
+          operation: "createChannel",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error)
+        },
+        error
+      );
+    }
+  }
+  createAuthnMiddleware() {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+      return yield* call.next(call.request, {
+        ...options,
+        metadata
+      });
+    }.bind(this);
+  }
+  createMiddleware(address, initialAuthToken) {
+    return async function* (call, options) {
+      const metadata = Metadata(options.metadata).set("X-Requested-With", "XMLHttpRequest").set("X-Grpc-Web", "1").set("X-Client-Env", clientEnv).set("Content-Type", "application/grpc-web+proto");
+      try {
+        return yield* call.next(call.request, {
+          ...options,
+          metadata: metadata.set(
+            "Authorization",
+            `Bearer ${this.clients.get(address)?.authToken || initialAuthToken}`
+          )
+        });
+      } catch (error) {
+        return yield* this.handleMiddlewareError(
+          error,
+          address,
+          call,
+          metadata,
+          options
+        );
+      }
+    }.bind(this);
+  }
+  async createGrpcClient(defintion, channel, withRetries, middleware) {
+    let clientFactory;
+    const retryOptions = {
+      retry: true,
+      retryMaxAttempts: 3
+    };
+    let options = {};
+    clientFactory = createClientFactory();
+    if (withRetries) {
+      options = retryOptions;
+      clientFactory = clientFactory.use(retryMiddleware);
+    }
+    if (middleware) {
+      clientFactory = clientFactory.use(middleware);
+    }
+    const client = clientFactory.create(defintion, channel, {
+      "*": options
+    });
+    return {
+      ...client,
+      close: void 0
+    };
+  }
+};
+
+// src/spark-wallet/spark-wallet.browser.ts
+import { WebTracerProvider } from "@opentelemetry/sdk-trace-web";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+import { FetchInstrumentation } from "@opentelemetry/instrumentation-fetch";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { propagation } from "@opentelemetry/api";
+var SparkWalletBrowser = class extends SparkWallet {
+  buildConnectionManager(config) {
+    return new ConnectionManagerBrowser(config);
+  }
+  initializeTracerEnv({
+    spanProcessors,
+    traceUrls
+  }) {
+    console.log("initializeTracerEnvBrowser");
+    initializeTracerEnvBrowser({ spanProcessors, traceUrls });
+  }
+};
+function initializeTracerEnvBrowser({
+  spanProcessors,
+  traceUrls
+}) {
+  const provider = new WebTracerProvider({ spanProcessors });
+  provider.register();
+  propagation.setGlobalPropagator(new W3CTraceContextPropagator());
+  registerInstrumentations({
+    instrumentations: [
+      new FetchInstrumentation({
+        ignoreUrls: [
+          /* Since we're wrapping global fetch we should be careful to avoid
+             adding headers for unrelated requests */
+          new RegExp(
+            `^(?!(${traceUrls.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")}))`
+          )
+        ],
+        propagateTraceHeaderCorsUrls: /.*/
+      })
+    ]
+  });
+}
+
+export {
+  ConnectionManagerBrowser,
+  SparkWalletBrowser,
+  initializeTracerEnvBrowser
+};