@spotify-confidence/openfeature-server-provider-local 0.6.0 → 0.7.0

package/dist/{index.browser.js → index.fetch.js}

@@ -1238,7 +1238,7 @@ function isObject(value) {
 function isSet$3(value) {
 	return value !== null && value !== void 0;
 }
-const VERSION = "0.6.0";
+const VERSION = "0.7.0";
 const NOOP_LOG_FN = Object.assign(() => {}, { enabled: false });
 const debugBackend = loadDebug();
 const logger$2 = new class LoggerImpl {
@@ -2382,8 +2382,12 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 	flushInterval;
 	materializationStore;
 	stateEtag = null;
-	constructor(resolver$1, options) {
-		this.resolver = resolver$1;
+	get resolver() {
+		if (this.resolverOrPromise instanceof Promise) throw new Error("Resolver not ready");
+		return this.resolverOrPromise;
+	}
+	constructor(resolverOrPromise, options) {
+		this.resolverOrPromise = resolverOrPromise;
 		this.options = options;
 		this.stateUpdateInterval = options.stateUpdateInterval ?? DEFAULT_STATE_INTERVAL;
 		if (!Number.isInteger(this.stateUpdateInterval) || this.stateUpdateInterval < 1e3) throw new Error(`stateUpdateInterval must be an integer >= 1000 (1s), currently: ${this.stateUpdateInterval}`);
@@ -2421,6 +2425,7 @@ var ConfidenceServerProviderLocal = class ConfidenceServerProviderLocal {
 		const signal = this.main.signal;
 		const initialUpdateSignal = AbortSignal.any([signal, timeoutSignal(this.options.initializeTimeout ?? DEFAULT_INITIALIZE_TIMEOUT)]);
 		try {
+			this.resolverOrPromise = await this.resolverOrPromise;
 			await this.updateState(initialUpdateSignal);
 			scheduleWithFixedInterval((signal$1) => this.flush(signal$1), this.flushInterval, {
 				maxConcurrent: 3,
@@ -2818,8 +2823,8 @@ function verifyExports(exports) {
 var UnsafeWasmResolver = class {
 	exports;
 	flushCount = 0;
-	constructor(module$1) {
-		const { exports } = new WebAssembly.Instance(module$1, { wasm_msg: { wasm_msg_host_current_time: () => {
+	constructor(module) {
+		const { exports } = new WebAssembly.Instance(module, { wasm_msg: { wasm_msg_host_current_time: () => {
 			const epochMillisecond = Date.now();
 			const seconds = Math.floor(epochMillisecond / 1e3);
 			const nanos = (epochMillisecond - 1e3 * seconds) * 1e6;
@@ -2882,15 +2887,15 @@ var UnsafeWasmResolver = class {
 		this.exports.wasm_msg_free(ptr);
 	}
 };
-const DEFAULT_DELEGATE_FACTORY = (module$1) => new UnsafeWasmResolver(module$1);
+const DEFAULT_DELEGATE_FACTORY = (module) => new UnsafeWasmResolver(module);
 var WasmResolver = class {
 	delegate;
 	currentState;
 	bufferedLogs = [];
-	constructor(module$1, delegateFactory = DEFAULT_DELEGATE_FACTORY) {
-		this.module = module$1;
+	constructor(module, delegateFactory = DEFAULT_DELEGATE_FACTORY) {
+		this.module = module;
 		this.delegateFactory = delegateFactory;
-		this.delegate = delegateFactory(module$1);
+		this.delegate = delegateFactory(module);
 	}
 	reloadInstance(error) {
 		logger.error("Failure calling into wasm:", error);
@@ -2940,10 +2945,13 @@ var WasmResolver = class {
 		return this.delegate.flushAssigned();
 	}
 };
-const wasmUrl = new URL("confidence_resolver.wasm", import.meta.url);
-const module = await WebAssembly.compileStreaming(fetch(wasmUrl));
-const resolver = new WasmResolver(module);
-function createConfidenceServerProvider(options) {
+let resolver = null;
+function createConfidenceServerProvider({ wasmUrl,...options }) {
+	if (!resolver) resolver = createResolver(wasmUrl ?? new URL("confidence_resolver.wasm", import.meta.url));
 	return new ConfidenceServerProviderLocal(resolver, options);
 }
+async function createResolver(wasmUrl) {
+	const module = await WebAssembly.compileStreaming(fetch(wasmUrl));
+	return new WasmResolver(module);
+}
 export { createConfidenceServerProvider };

package/dist/{index.browser.d.ts → index.inlined.d.ts}

@@ -414,7 +414,7 @@ interface ProviderOptions {
 * @public
 */
 declare class ConfidenceServerProviderLocal implements Provider {
-  private resolver;
+  private resolverOrPromise;
   private options;
   /** Static data about the provider */
   readonly metadata: ProviderMetadata;
@@ -426,7 +426,8 @@ declare class ConfidenceServerProviderLocal implements Provider {
   private readonly flushInterval;
   private readonly materializationStore;
   private stateEtag;
-  constructor(resolver: LocalResolver, options: ProviderOptions);
+  private get resolver();
+  constructor(resolverOrPromise: LocalResolver | Promise<LocalResolver>, options: ProviderOptions);
   initialize(context?: EvaluationContext): Promise<void>;
   onClose(): Promise<void>;
   evaluate<T>(flagKey: string, defaultValue: T, context: EvaluationContext): Promise<ResolutionDetails<T>>;
@@ -453,7 +454,8 @@ declare class ConfidenceServerProviderLocal implements Provider {
   resolveStringEvaluation(flagKey: string, defaultValue: string, context: EvaluationContext): Promise<ResolutionDetails<string>>;
 }
 //#endregion
-//#region src/index.browser.d.ts
+//#region src/index.inlined.d.ts
+type ProviderOptionsExt = ProviderOptions;
 declare function createConfidenceServerProvider(options: ProviderOptions): ConfidenceServerProviderLocal;
 //#endregion
-export { type MaterializationStore, createConfidenceServerProvider };
+export { type MaterializationStore, ProviderOptionsExt, createConfidenceServerProvider };