@ricsam/isolate-client 0.1.9 → 0.1.10

package/README.md

@@ -85,7 +85,10 @@ const namespace = client.createNamespace("tenant-123");
 // Create a runtime in this namespace
 const runtime = await namespace.createRuntime({
   memoryLimitMB: 128,
-  moduleLoader: async (name) => loadModule(name),
+  moduleLoader: async (name, importer) => {
+    const code = loadModule(name);
+    return { code, resolveDir: importer.resolveDir };
+  },
 });
 
 console.log(runtime.reused); // false - first time
@@ -145,21 +148,29 @@ interface Namespace {
 
 ## Module Loader
 
-Register a custom module loader to handle dynamic `import()` calls:
+Register a custom module loader to handle dynamic `import()` calls. The loader receives the module specifier and importer info, and returns an object with the source code and `resolveDir` (used to resolve nested relative imports):
 
 ```typescript
 const runtime = await client.createRuntime({
-  moduleLoader: async (moduleName: string) => {
+  moduleLoader: async (moduleName: string, importer) => {
+    // importer.path = resolved path of importing module
+    // importer.resolveDir = directory for relative resolution
     if (moduleName === "@/db") {
-      return `
-        export async function getUser(id) {
-          const response = await fetch("/api/users/" + id);
-          return response.json();
-        }
-      `;
+      return {
+        code: `
+          export async function getUser(id) {
+            const response = await fetch("/api/users/" + id);
+            return response.json();
+          }
+        `,
+        resolveDir: "/modules",
+      };
     }
     if (moduleName === "@/config") {
-      return `export const API_KEY = "sk-xxx";`;
+      return {
+        code: `export const API_KEY = "sk-xxx";`,
+        resolveDir: "/modules",
+      };
     }
     throw new Error(`Unknown module: ${moduleName}`);
   },

package/dist/cjs/connection.cjs

@@ -1,7 +1,20 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
   var entry = __moduleCache.get(from), desc;
@@ -33,6 +46,7 @@ __export(exports_connection, {
 });
 module.exports = __toCommonJS(exports_connection);
 var import_node_net = require("node:net");
+var import_node_path = __toESM(require("node:path"));
 var import_isolate_protocol = require("@ricsam/isolate-protocol");
 var import_client = require("@ricsam/isolate-playwright/client");
 var DEFAULT_TIMEOUT = 30000;
@@ -899,15 +913,15 @@ function registerFsCallbacks(state, callbacks) {
   const registrations = {};
   if (callbacks.readFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      const result = await callbacks.readFile(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      const result = await callbacks.readFile(path2);
       return new Uint8Array(result);
     });
     registrations.readFile = { callbackId, name: "readFile", type: "async" };
   }
   if (callbacks.writeFile) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, data) => {
+    state.callbacks.set(callbackId, async (path2, data) => {
       let buffer;
       if (data instanceof Uint8Array) {
         buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -918,42 +932,42 @@ function registerFsCallbacks(state, callbacks) {
       } else {
         buffer = new ArrayBuffer(0);
       }
-      await callbacks.writeFile(path, buffer);
+      await callbacks.writeFile(path2, buffer);
     });
     registrations.writeFile = { callbackId, name: "writeFile", type: "async" };
   }
   if (callbacks.unlink) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.unlink(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.unlink(path2);
     });
     registrations.unlink = { callbackId, name: "unlink", type: "async" };
   }
   if (callbacks.readdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.readdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.readdir(path2);
     });
     registrations.readdir = { callbackId, name: "readdir", type: "async" };
   }
   if (callbacks.mkdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path, options) => {
-      await callbacks.mkdir(path, options);
+    state.callbacks.set(callbackId, async (path2, options) => {
+      await callbacks.mkdir(path2, options);
     });
     registrations.mkdir = { callbackId, name: "mkdir", type: "async" };
   }
   if (callbacks.rmdir) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      await callbacks.rmdir(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      await callbacks.rmdir(path2);
     });
     registrations.rmdir = { callbackId, name: "rmdir", type: "async" };
   }
   if (callbacks.stat) {
     const callbackId = state.nextCallbackId++;
-    state.callbacks.set(callbackId, async (path) => {
-      return callbacks.stat(path);
+    state.callbacks.set(callbackId, async (path2) => {
+      return callbacks.stat(path2);
     });
     registrations.stat = { callbackId, name: "stat", type: "async" };
   }
@@ -968,15 +982,13 @@ function registerFsCallbacks(state, callbacks) {
 }
 function registerModuleLoaderCallback(state, callback) {
   const callbackId = state.nextCallbackId++;
-  state.callbacks.set(callbackId, async (moduleName) => {
+  state.callbacks.set(callbackId, async (moduleName, importer) => {
     const specifier = moduleName;
-    const cached = state.moduleSourceCache.get(specifier);
-    if (cached !== undefined) {
-      return cached;
-    }
-    const source = await callback(specifier);
-    state.moduleSourceCache.set(specifier, source);
-    return source;
+    const importerInfo = importer;
+    const result = await callback(specifier, importerInfo);
+    const resolvedPath = import_node_path.default.posix.join(result.resolveDir, import_node_path.default.posix.basename(specifier));
+    state.moduleSourceCache.set(resolvedPath, result.code);
+    return result;
   });
   return { callbackId, name: "moduleLoader", type: "async" };
 }
@@ -1302,4 +1314,4 @@ async function sendBodyStream(state, streamId, body) {
   }
 }
 
-//# debugId=88982DC84A5B7DE464756E2164756E21
+//# debugId=65FD012AB9411FDF64756E2164756E21