@protoc-gen-go-wasmjs/runtime 0.0.14

package/dist/index.js

@@ -0,0 +1,764 @@
+'use strict';
+
+// src/browser/service-manager.ts
+var BrowserServiceManager = class {
+  constructor() {
+    this.processing = false;
+    this.serviceImplementations = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a browser service implementation
+   */
+  registerService(name, implementation) {
+    this.serviceImplementations.set(name, implementation);
+  }
+  /**
+   * Set the WASM module reference
+   */
+  setWasmModule(wasmModule) {
+    this.wasmModule = wasmModule;
+  }
+  /**
+   * Start processing browser service calls
+   */
+  async startProcessing() {
+    if (this.processing) return;
+    this.processing = true;
+    while (this.processing) {
+      const call = this.getNextBrowserCall();
+      if (!call) {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        continue;
+      }
+      this.processCall(call);
+    }
+  }
+  /**
+   * Process a single browser service call asynchronously
+   */
+  async processCall(call) {
+    try {
+      const service = this.serviceImplementations.get(call.service);
+      if (!service) {
+        throw new Error(`No implementation registered for service: ${call.service}`);
+      }
+      const methodName = call.method.charAt(0).toLowerCase() + call.method.slice(1);
+      const method = service[methodName];
+      if (!method) {
+        throw new Error(`Method ${methodName} not found on service ${call.service}`);
+      }
+      const request = JSON.parse(call.request);
+      const response = await Promise.resolve(method.call(service, request));
+      console.log(`DEBUG: Browser service response for ${call.service}.${call.method}:`, response);
+      const jsonResponse = JSON.stringify(response);
+      console.log(`DEBUG: JSON stringified response:`, jsonResponse);
+      this.deliverBrowserResponse(call.id, jsonResponse, null);
+    } catch (error) {
+      this.deliverBrowserResponse(call.id, null, error.message || String(error));
+    }
+  }
+  /**
+   * Stop processing browser service calls
+   */
+  stopProcessing() {
+    this.processing = false;
+  }
+  /**
+   * Get the next browser call from WASM
+   */
+  getNextBrowserCall() {
+    if (typeof window.__wasmGetNextBrowserCall === "function") {
+      return window.__wasmGetNextBrowserCall();
+    }
+    return null;
+  }
+  /**
+   * Deliver a response back to WASM (called internally)
+   */
+  deliverBrowserResponse(callId, response, error) {
+    if (!window.__wasmDeliverBrowserResponse) {
+      return false;
+    }
+    return window.__wasmDeliverBrowserResponse(callId, response, error);
+  }
+};
+
+// src/schema/types.ts
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["STRING"] = "string";
+  FieldType2["NUMBER"] = "number";
+  FieldType2["BOOLEAN"] = "boolean";
+  FieldType2["MESSAGE"] = "message";
+  FieldType2["REPEATED"] = "repeated";
+  FieldType2["MAP"] = "map";
+  FieldType2["ONEOF"] = "oneof";
+  return FieldType2;
+})(FieldType || {});
+
+// src/schema/base-deserializer.ts
+var BaseDeserializer = class {
+  constructor(schemaRegistry, factory) {
+    this.schemaRegistry = schemaRegistry;
+    this.factory = factory;
+  }
+  /**
+   * Deserialize an object using schema information
+   * @param instance The target instance to populate
+   * @param data The source data to deserialize from
+   * @param messageType The fully qualified message type (e.g., "library.v1.Book")
+   * @returns The populated instance
+   */
+  deserialize(instance, data, messageType) {
+    if (!data || typeof data !== "object") {
+      return instance;
+    }
+    const schema = this.schemaRegistry[messageType];
+    if (!schema) {
+      return this.fallbackDeserialize(instance, data);
+    }
+    for (const fieldSchema of schema.fields) {
+      const fieldValue = data[fieldSchema.name];
+      if (fieldValue === null || fieldValue === void 0) {
+        continue;
+      }
+      this.deserializeField(instance, fieldSchema, fieldValue);
+    }
+    return instance;
+  }
+  /**
+   * Deserialize a single field based on its schema
+   */
+  deserializeField(instance, fieldSchema, fieldValue) {
+    const fieldName = fieldSchema.name;
+    switch (fieldSchema.type) {
+      case "string" /* STRING */:
+      case "number" /* NUMBER */:
+      case "boolean" /* BOOLEAN */:
+        instance[fieldName] = fieldValue;
+        break;
+      case "message" /* MESSAGE */:
+        if (fieldSchema.repeated) {
+          instance[fieldName] = this.deserializeMessageArray(
+            fieldValue,
+            fieldSchema.messageType,
+            instance,
+            fieldName
+          );
+        } else {
+          instance[fieldName] = this.deserializeMessageField(
+            fieldValue,
+            fieldSchema.messageType,
+            instance,
+            fieldName
+          );
+        }
+        break;
+      case "repeated" /* REPEATED */:
+        if (Array.isArray(fieldValue)) {
+          instance[fieldName] = [...fieldValue];
+        }
+        break;
+      case "oneof" /* ONEOF */:
+        instance[fieldName] = fieldValue;
+        break;
+      case "map" /* MAP */:
+        instance[fieldName] = { ...fieldValue };
+        break;
+      default:
+        instance[fieldName] = fieldValue;
+        break;
+    }
+  }
+  /**
+   * Deserialize a single message field
+   */
+  deserializeMessageField(fieldValue, messageType, parent, attributeName) {
+    let factoryMethod;
+    if (this.factory.getFactoryMethod) {
+      factoryMethod = this.factory.getFactoryMethod(messageType);
+    } else {
+      const factoryMethodName = this.getFactoryMethodName(messageType);
+      factoryMethod = this.factory[factoryMethodName];
+    }
+    if (factoryMethod) {
+      const result = factoryMethod(parent, attributeName, void 0, fieldValue);
+      if (result.fullyLoaded) {
+        return result.instance;
+      } else {
+        return this.deserialize(result.instance, fieldValue, messageType);
+      }
+    }
+    return this.fallbackDeserialize({}, fieldValue);
+  }
+  /**
+   * Deserialize an array of message objects
+   */
+  deserializeMessageArray(fieldValue, messageType, parent, attributeName) {
+    if (!Array.isArray(fieldValue)) {
+      return [];
+    }
+    let factoryMethod;
+    if (this.factory.getFactoryMethod) {
+      factoryMethod = this.factory.getFactoryMethod(messageType);
+    } else {
+      const factoryMethodName = this.getFactoryMethodName(messageType);
+      factoryMethod = this.factory[factoryMethodName];
+    }
+    return fieldValue.map((item, index) => {
+      if (factoryMethod) {
+        const result = factoryMethod(parent, attributeName, index, item);
+        if (result.fullyLoaded) {
+          return result.instance;
+        } else {
+          return this.deserialize(result.instance, item, messageType);
+        }
+      }
+      return this.fallbackDeserialize({}, item);
+    });
+  }
+  /**
+   * Convert message type to factory method name
+   * "library.v1.Book" -> "newBook"
+   */
+  getFactoryMethodName(messageType) {
+    const parts = messageType.split(".");
+    const typeName = parts[parts.length - 1];
+    return "new" + typeName;
+  }
+  /**
+   * Fallback deserializer for when no schema is available
+   */
+  fallbackDeserialize(instance, data) {
+    if (!data || typeof data !== "object") {
+      return instance;
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (value !== null && value !== void 0) {
+        instance[key] = value;
+      }
+    }
+    return instance;
+  }
+  /**
+   * Create and deserialize a new instance of a message type
+   */
+  createAndDeserialize(messageType, data) {
+    let factoryMethod;
+    if (this.factory.getFactoryMethod) {
+      factoryMethod = this.factory.getFactoryMethod(messageType);
+    } else {
+      const factoryMethodName = this.getFactoryMethodName(messageType);
+      factoryMethod = this.factory[factoryMethodName];
+    }
+    if (!factoryMethod) {
+      throw new Error(`Could not find factory method to deserialize: ${messageType}`);
+    }
+    const result = factoryMethod(void 0, void 0, void 0, data);
+    if (result.fullyLoaded) {
+      return result.instance;
+    } else {
+      return this.deserialize(result.instance, data, messageType);
+    }
+  }
+};
+
+// src/schema/base-registry.ts
+var BaseSchemaRegistry = class {
+  constructor(schemaRegistry) {
+    this.schemaRegistry = schemaRegistry;
+  }
+  /**
+   * Get schema for a message type
+   */
+  getSchema(messageType) {
+    return this.schemaRegistry[messageType];
+  }
+  /**
+   * Get field schema by name
+   */
+  getFieldSchema(messageType, fieldName) {
+    const schema = this.getSchema(messageType);
+    return schema?.fields.find((field) => field.name === fieldName);
+  }
+  /**
+   * Get field schema by proto field ID
+   */
+  getFieldSchemaById(messageType, fieldId) {
+    const schema = this.getSchema(messageType);
+    return schema?.fields.find((field) => field.id === fieldId);
+  }
+  /**
+   * Check if field is part of a oneof group
+   */
+  isOneofField(messageType, fieldName) {
+    const fieldSchema = this.getFieldSchema(messageType, fieldName);
+    return fieldSchema?.oneofGroup !== void 0;
+  }
+  /**
+   * Get all fields in a oneof group
+   */
+  getOneofFields(messageType, oneofGroup) {
+    const schema = this.getSchema(messageType);
+    return schema?.fields.filter((field) => field.oneofGroup === oneofGroup) || [];
+  }
+};
+
+// src/client/types.ts
+var WasmError = class extends Error {
+  constructor(message, methodPath) {
+    super(message);
+    this.methodPath = methodPath;
+    this.name = "WasmError";
+  }
+};
+
+// src/client/base-client.ts
+var WASMServiceClient = class {
+  constructor() {
+    this.wasmLoadPromise = null;
+    this.browserServiceManager = null;
+    this.browserServiceManager = new BrowserServiceManager();
+  }
+  /**
+   * Register a browser service implementation
+   * Can be used to register browser services from any package
+   */
+  registerBrowserService(name, implementation) {
+    if (!this.browserServiceManager) {
+      throw new Error("Browser service manager not initialized");
+    }
+    this.browserServiceManager.registerService(name, implementation);
+  }
+  /**
+   * Check if WASM is ready for operations
+   */
+  isReady() {
+    return this.wasm !== null && this.wasm !== void 0;
+  }
+  /**
+   * Wait for WASM to be ready (use during initialization)
+   */
+  async waitUntilReady() {
+    if (!this.wasmLoadPromise) {
+      throw new Error("WASM loading not started. Call loadWasm() first.");
+    }
+    await this.wasmLoadPromise;
+  }
+  /**
+   * Internal method to call WASM functions with JSON conversion
+   */
+  callMethod(methodPath, request) {
+    this.ensureWASMLoaded();
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq));
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+      return wasmResponse.data;
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Internal method to call async WASM functions with callback
+   */
+  callMethodWithCallback(methodPath, request, callback) {
+    this.ensureWASMLoaded();
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq), callback);
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+      return Promise.resolve();
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Internal method to call server streaming WASM functions
+   */
+  callStreamingMethod(methodPath, request, callback) {
+    this.ensureWASMLoaded();
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wrappedCallback = (responseStr, error, done) => {
+        let response = null;
+        if (responseStr && !error) {
+          try {
+            response = JSON.parse(responseStr);
+          } catch (e) {
+            response = responseStr;
+          }
+        }
+        return callback(response, error, done);
+      };
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq), wrappedCallback);
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Streaming call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Ensure WASM module is loaded (synchronous version for service calls)
+   */
+  ensureWASMLoaded() {
+    if (!this.isReady()) {
+      throw new Error("WASM module not loaded. Call loadWasm() and waitUntilReady() first.");
+    }
+  }
+  /**
+   * Load the WASM module asynchronously
+   */
+  async loadWasm(wasmPath) {
+    if (this.wasmLoadPromise) {
+      return this.wasmLoadPromise;
+    }
+    this.wasmLoadPromise = this.loadWASMModule(wasmPath);
+    return this.wasmLoadPromise;
+  }
+};
+
+// src/client/wasm-bundle.ts
+var WASMBundle = class {
+  constructor(config) {
+    this.wasm = null;
+    this.wasmLoadPromise = null;
+    this.browserServiceManager = null;
+    this.config = config;
+    this.browserServiceManager = new BrowserServiceManager();
+  }
+  /**
+   * Register a browser service implementation
+   */
+  registerBrowserService(name, implementation) {
+    if (!this.browserServiceManager) {
+      throw new Error("Browser service manager not initialized");
+    }
+    this.browserServiceManager.registerService(name, implementation);
+  }
+  /**
+   * Check if WASM is ready for operations
+   */
+  isReady() {
+    return this.wasm !== null && this.wasm !== void 0;
+  }
+  /**
+   * Wait for WASM to be ready (use during initialization)
+   */
+  async waitUntilReady() {
+    if (!this.wasmLoadPromise) {
+      throw new Error("WASM loading not started. Call loadWasm() first.");
+    }
+    await this.wasmLoadPromise;
+  }
+  /**
+   * Load the WASM module asynchronously (singleton pattern)
+   */
+  async loadWasm(wasmPath) {
+    if (this.wasmLoadPromise) {
+      return this.wasmLoadPromise;
+    }
+    this.wasmLoadPromise = this.loadWASMModule(wasmPath);
+    return this.wasmLoadPromise;
+  }
+  /**
+   * Get WASM method function by path
+   */
+  getWasmMethod(methodPath) {
+    this.ensureWASMLoaded();
+    switch (this.config.apiStructure) {
+      case "namespaced":
+        const parts = methodPath.split(".");
+        let current = this.wasm;
+        for (const part of parts) {
+          current = current[part];
+          if (!current) {
+            throw new Error(`Method not found: ${methodPath}`);
+          }
+        }
+        return current;
+      case "flat":
+        const method = this.wasm[methodPath];
+        if (!method) {
+          throw new Error(`Method not found: ${methodPath}`);
+        }
+        return method;
+      case "service_based":
+        const serviceParts = methodPath.split(".");
+        let serviceCurrent = this.wasm;
+        for (const part of serviceParts) {
+          serviceCurrent = serviceCurrent[part];
+          if (!serviceCurrent) {
+            throw new Error(`Method not found: ${methodPath}`);
+          }
+        }
+        return serviceCurrent;
+      default:
+        throw new Error(`Unsupported API structure: ${this.config.apiStructure}`);
+    }
+  }
+  /**
+   * Internal method to call WASM functions with JSON conversion
+   */
+  callMethod(methodPath, request) {
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq));
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+      return wasmResponse.data;
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Internal method to call async WASM functions with callback
+   */
+  callMethodWithCallback(methodPath, request, callback) {
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq), callback);
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+      return Promise.resolve();
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Internal method to call server streaming WASM functions
+   */
+  callStreamingMethod(methodPath, request, callback) {
+    try {
+      const jsonReq = JSON.parse(JSON.stringify(request));
+      const wasmMethod = this.getWasmMethod(methodPath);
+      const wrappedCallback = (responseStr, error, done) => {
+        let response = null;
+        if (responseStr && !error) {
+          try {
+            response = JSON.parse(responseStr);
+          } catch (e) {
+            response = responseStr;
+          }
+        }
+        return callback(response, error, done);
+      };
+      const wasmResponse = wasmMethod(JSON.stringify(jsonReq), wrappedCallback);
+      if (!wasmResponse.success) {
+        throw new WasmError(wasmResponse.message, methodPath);
+      }
+    } catch (error) {
+      if (error instanceof WasmError) {
+        throw error;
+      }
+      throw new WasmError(
+        `Streaming call error: ${error instanceof Error ? error.message : String(error)}`,
+        methodPath
+      );
+    }
+  }
+  /**
+   * Ensure WASM module is loaded (synchronous version for service calls)
+   */
+  ensureWASMLoaded() {
+    if (!this.isReady()) {
+      throw new Error("WASM module not loaded. Call loadWasm() and waitUntilReady() first.");
+    }
+  }
+  /**
+   * Load the WASM module implementation
+   */
+  async loadWASMModule(wasmPath) {
+    console.log(`Loading ${this.config.moduleName} WASM module...`);
+    if (this.checkIfPreLoaded()) {
+      console.log("WASM module already loaded (pre-loaded in test environment)");
+      return;
+    }
+    if (!window.Go) {
+      const script = document.createElement("script");
+      script.src = "/wasm_exec.js";
+      document.head.appendChild(script);
+      await new Promise((resolve, reject) => {
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error("Failed to load wasm_exec.js"));
+      });
+    }
+    const go = new window.Go();
+    const wasmModule = await WebAssembly.instantiateStreaming(
+      fetch(wasmPath),
+      go.importObject
+    );
+    go.run(wasmModule.instance);
+    if (this.browserServiceManager) {
+      this.browserServiceManager.setWasmModule(window);
+      this.browserServiceManager.startProcessing();
+    }
+    this.verifyWASMLoaded();
+    console.log(`${this.config.moduleName} WASM module loaded successfully`);
+  }
+  /**
+   * Check if WASM is pre-loaded (for testing)
+   */
+  checkIfPreLoaded() {
+    switch (this.config.apiStructure) {
+      case "namespaced":
+        if (window[this.config.jsNamespace]) {
+          this.wasm = window[this.config.jsNamespace];
+          return true;
+        }
+        return false;
+      case "flat":
+        if (window[this.config.jsNamespace + "LoadUserData"]) {
+          this.wasm = window;
+          return true;
+        }
+        return false;
+      case "service_based":
+        if (window.services) {
+          this.wasm = window.services;
+          return true;
+        }
+        return false;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Verify WASM APIs are available after loading
+   */
+  verifyWASMLoaded() {
+    switch (this.config.apiStructure) {
+      case "namespaced":
+        if (!window[this.config.jsNamespace]) {
+          throw new Error("WASM APIs not found - module may not have loaded correctly");
+        }
+        this.wasm = window[this.config.jsNamespace];
+        break;
+      case "flat":
+        if (!window[this.config.jsNamespace + "LoadUserData"]) {
+          throw new Error("WASM APIs not found - module may not have loaded correctly");
+        }
+        this.wasm = window;
+        break;
+      case "service_based":
+        if (!window.services) {
+          throw new Error("WASM APIs not found - module may not have loaded correctly");
+        }
+        this.wasm = window.services;
+        break;
+      default:
+        throw new Error(`Unsupported API structure: ${this.config.apiStructure}`);
+    }
+  }
+};
+
+// src/client/service-client.ts
+var ServiceClient = class {
+  constructor(bundle) {
+    this.bundle = bundle;
+  }
+  /**
+   * Check if the underlying WASM bundle is ready
+   */
+  isReady() {
+    return this.bundle.isReady();
+  }
+  /**
+   * Wait for the underlying WASM bundle to be ready
+   */
+  async waitUntilReady() {
+    return this.bundle.waitUntilReady();
+  }
+  /**
+   * Call a synchronous WASM method
+   */
+  callMethod(methodPath, request) {
+    return this.bundle.callMethod(methodPath, request);
+  }
+  /**
+   * Call an asynchronous WASM method with callback
+   */
+  callMethodWithCallback(methodPath, request, callback) {
+    return this.bundle.callMethodWithCallback(methodPath, request, callback);
+  }
+  /**
+   * Call a server streaming WASM method
+   */
+  callStreamingMethod(methodPath, request, callback) {
+    return this.bundle.callStreamingMethod(methodPath, request, callback);
+  }
+};
+
+// src/types/patches.ts
+var PatchOperation = /* @__PURE__ */ ((PatchOperation2) => {
+  PatchOperation2["SET"] = "SET";
+  PatchOperation2["INSERT_LIST"] = "INSERT_LIST";
+  PatchOperation2["REMOVE_LIST"] = "REMOVE_LIST";
+  PatchOperation2["MOVE_LIST"] = "MOVE_LIST";
+  PatchOperation2["INSERT_MAP"] = "INSERT_MAP";
+  PatchOperation2["REMOVE_MAP"] = "REMOVE_MAP";
+  PatchOperation2["CLEAR_LIST"] = "CLEAR_LIST";
+  PatchOperation2["CLEAR_MAP"] = "CLEAR_MAP";
+  return PatchOperation2;
+})(PatchOperation || {});
+var PatchSource = /* @__PURE__ */ ((PatchSource2) => {
+  PatchSource2["LOCAL"] = "LOCAL";
+  PatchSource2["REMOTE"] = "REMOTE";
+  PatchSource2["SERVER"] = "SERVER";
+  PatchSource2["STORAGE"] = "STORAGE";
+  return PatchSource2;
+})(PatchSource || {});
+
+exports.BaseDeserializer = BaseDeserializer;
+exports.BaseSchemaRegistry = BaseSchemaRegistry;
+exports.BrowserServiceManager = BrowserServiceManager;
+exports.FieldType = FieldType;
+exports.PatchOperation = PatchOperation;
+exports.PatchSource = PatchSource;
+exports.ServiceClient = ServiceClient;
+exports.WASMBundle = WASMBundle;
+exports.WASMServiceClient = WASMServiceClient;
+exports.WasmError = WasmError;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map