solid-tag-runtime 0.0.7 → 0.0.8

package/src/runtime.js

@@ -5,6 +5,7 @@ import {
   SolidTagRuntimeError,
 } from "./errors.js";
 import { createDefaultModuleUrlBackend } from "./url-backend.js";
+import { createEventDispatcher } from "./events.js";
 
 const HOST_REGISTRY_KEY = "__solidTagRuntimeHostModules__";
 let runtimeSequence = 0;
@@ -27,7 +28,11 @@ export function createRuntime(options = {}) {
   const records = new Map();
   let anonymousSequence = 0;
   let disposed = false;
-  const subscribers = new Set();
+  const events = createEventDispatcher({
+    onListenerError(error) {
+      globalThis.console?.error?.("solid-tag-runtime lifecycle subscriber error", error);
+    },
+  });
   let eventBufferDepth = 0;
   const eventBuffer = [];
 
@@ -102,7 +107,13 @@ export function createRuntime(options = {}) {
 
     eventBufferDepth += 1;
     try {
-      return prepared.map(item => defineSource(item.id, item.source, { format: item.format }, "defineMany"));
+      const ids = prepared.map(item => defineSource(item.id, item.source, { format: item.format }, "defineMany"));
+      emit({
+        type: "modules-defined",
+        ids: [...ids],
+        modules: ids.map(id => toModuleInfo(records.get(id))),
+      });
+      return ids;
     } finally {
       eventBufferDepth -= 1;
       if (eventBufferDepth === 0) flushEventBuffer();
@@ -146,6 +157,17 @@ export function createRuntime(options = {}) {
       replaced: Boolean(existing),
       module: toModuleInfo(record),
     });
+    if (operation === "update") {
+      emit({
+        type: "module-updated",
+        id: normalized,
+        kind: record.kind,
+        previousVersion: existing?.version ?? 0,
+        version: record.version,
+        format: record.format,
+        module: toModuleInfo(record),
+      });
+    }
     return normalized;
   }
 
@@ -251,9 +273,11 @@ export function createRuntime(options = {}) {
     }
 
     if (!record.importPromise) {
-      record.state = "evaluating";
-      emit({ type: "module-evaluating", id: record.id, kind: record.kind, version: record.version });
-      record.importPromise = ensureSourceUrl(record, []).then(url => import(url)).then(namespace => {
+      record.importPromise = ensureSourceUrl(record, []).then(url => {
+        record.state = "evaluating";
+        emit({ type: "module-evaluating", id: record.id, kind: record.kind, version: record.version });
+        return import(url);
+      }).then(namespace => {
         record.namespace = namespace;
         record.state = "ready";
         emit({ type: "module-evaluated", id: record.id, kind: record.kind, version: record.version, module: toModuleInfo(record) });
@@ -421,13 +445,9 @@ export function createRuntime(options = {}) {
     return ids;
   }
 
-  function subscribe(listener) {
+  function subscribe(typesOrListener, maybeListener) {
     assertActive();
-    if (typeof listener !== "function") {
-      throw new TypeError("subscribe(listener) expects a function.");
-    }
-    subscribers.add(listener);
-    return () => subscribers.delete(listener);
+    return events.subscribe(typesOrListener, maybeListener);
   }
 
   function listModules() {
@@ -458,7 +478,7 @@ export function createRuntime(options = {}) {
     records.clear();
     hostNamespaces.clear();
     globalRegistry.delete(runtimeId);
-    subscribers.clear();
+    events.clear();
   }
 
   function resolvePublic(specifier, importer) {
@@ -470,11 +490,19 @@ export function createRuntime(options = {}) {
 
     if (stack.includes(record.id)) {
       const cycleStart = stack.indexOf(record.id);
-      throw new CircularDependencyError([...stack.slice(cycleStart), record.id]);
+      const error = new CircularDependencyError([...stack.slice(cycleStart), record.id]);
+      emitError(record, "link", error);
+      throw error;
     }
 
     const nextStack = [...stack, record.id];
     record.state = "linking";
+    emit({
+      type: "module-linking",
+      id: record.id,
+      kind: record.kind,
+      version: record.version,
+    });
 
     let analysis;
     try {
@@ -487,79 +515,126 @@ export function createRuntime(options = {}) {
     }
 
     const resolvedImports = [];
+    const linkedDependencies = [];
     const nextDependencies = new Set();
 
     for (const reference of analysis.imports ?? []) {
-      const resolved = resolveSpecifier(reference.specifier, record.id);
+      let resolved;
+      try {
+        resolved = resolveSpecifier(reference.specifier, record.id);
+      } catch (error) {
+        record.state = "error";
+        emitError(record, "resolve", error);
+        throw error;
+      }
+
       const dependencyRecord = records.get(resolved);
       let replacement = resolved;
 
-      if (dependencyRecord) {
-        nextDependencies.add(dependencyRecord.id);
-
-        if (dependencyRecord.kind === "source") {
-          replacement = await ensureSourceUrl(dependencyRecord, nextStack);
-        } else if (dependencyRecord.kind === "host") {
-          replacement = await ensureHostUrl(dependencyRecord);
-        } else {
-          replacement = dependencyRecord.externalUrl;
+      try {
+        if (dependencyRecord) {
+          nextDependencies.add(dependencyRecord.id);
+
+          if (dependencyRecord.kind === "source") {
+            replacement = await ensureSourceUrl(dependencyRecord, nextStack);
+          } else if (dependencyRecord.kind === "host") {
+            replacement = await ensureHostUrl(dependencyRecord);
+          } else {
+            replacement = dependencyRecord.externalUrl;
+          }
+        } else if (isRelativeSpecifier(reference.specifier) || reference.specifier.startsWith("/")) {
+          throw new ModuleResolutionError(reference.specifier, record.id);
+        } else if (!allowNativeImports && !isAbsoluteUrl(resolved)) {
+          throw new ModuleResolutionError(reference.specifier, record.id);
         }
-      } else if (isRelativeSpecifier(reference.specifier) || reference.specifier.startsWith("/")) {
-        throw new ModuleResolutionError(reference.specifier, record.id);
-      } else if (!allowNativeImports && !isAbsoluteUrl(resolved)) {
-        throw new ModuleResolutionError(reference.specifier, record.id);
+      } catch (error) {
+        record.state = "error";
+        emitError(record, error instanceof ModuleResolutionError ? "resolve" : "link", error);
+        throw error;
       }
 
       resolvedImports.push({ ...reference, replacement });
+      linkedDependencies.push({
+        specifier: reference.specifier,
+        resolvedId: dependencyRecord?.id ?? resolved,
+      });
     }
 
-    let linkedSource = applyImportReplacements(record.source, resolvedImports);
-
-    // JSX produced by solid-tag needs @solidjs/html. Resolve it through the
-    // same module system so host applications can share their existing runtime.
-    let htmlImportSource;
-    const needsHtmlRuntime = record.format !== "js" && analysis.needsHtmlRuntime !== false;
-    if (needsHtmlRuntime) {
-      const htmlResolved = resolveSpecifier("@solidjs/html", record.id);
-      const htmlRecord = records.get(htmlResolved);
-
-      if (htmlRecord) {
-        nextDependencies.add(htmlRecord.id);
-        htmlImportSource = htmlRecord.kind === "source"
-          ? await ensureSourceUrl(htmlRecord, nextStack)
-          : htmlRecord.kind === "host"
-            ? await ensureHostUrl(htmlRecord)
-            : htmlRecord.externalUrl;
-      } else if (allowNativeImports) {
-        htmlImportSource = htmlResolved;
-      } else {
-        throw new ModuleResolutionError("@solidjs/html", record.id);
+    let linkedSource;
+    try {
+      linkedSource = applyImportReplacements(record.source, resolvedImports);
+
+      // JSX produced by solid-tag needs @solidjs/html. Resolve it through the
+      // same module system so host applications can share their existing runtime.
+      let htmlImportSource;
+      const needsHtmlRuntime = record.format !== "js" && analysis.needsHtmlRuntime !== false;
+      if (needsHtmlRuntime) {
+        const htmlResolved = resolveSpecifier("@solidjs/html", record.id);
+        const htmlRecord = records.get(htmlResolved);
+
+        if (htmlRecord) {
+          nextDependencies.add(htmlRecord.id);
+          htmlImportSource = htmlRecord.kind === "source"
+            ? await ensureSourceUrl(htmlRecord, nextStack)
+            : htmlRecord.kind === "host"
+              ? await ensureHostUrl(htmlRecord)
+              : htmlRecord.externalUrl;
+        } else if (allowNativeImports) {
+          htmlImportSource = htmlResolved;
+        } else {
+          throw new ModuleResolutionError("@solidjs/html", record.id);
+        }
+
+        linkedDependencies.push({
+          specifier: "@solidjs/html",
+          resolvedId: htmlRecord?.id ?? htmlResolved,
+        });
       }
-    }
 
-    syncDependencyEdges(record, nextDependencies);
+      syncDependencyEdges(record, nextDependencies);
+      emit({
+        type: "module-linked",
+        id: record.id,
+        kind: record.kind,
+        version: record.version,
+        dependencies: linkedDependencies,
+        module: toModuleInfo(record),
+      });
 
-    try {
-      if (record.format === "js") {
-        record.compiledCode = linkedSource;
-        record.diagnostics = [];
-      } else {
-        const transformed = compiler.transform(linkedSource, {
-          id: record.id,
-          format: record.format,
-          htmlImportSource,
-        });
-        record.compiledCode = transformed.code;
-        record.diagnostics = [...(transformed.diagnostics ?? [])];
+      try {
+        if (record.format === "js") {
+          record.compiledCode = linkedSource;
+          record.diagnostics = [];
+        } else {
+          const transformed = compiler.transform(linkedSource, {
+            id: record.id,
+            format: record.format,
+            htmlImportSource,
+          });
+          record.compiledCode = transformed.code;
+          record.diagnostics = [...(transformed.diagnostics ?? [])];
+        }
+      } catch (error) {
+        record.state = "error";
+        const wrapped = new ModuleCompileError(record.id, error);
+        emitError(record, "compile", wrapped);
+        throw wrapped;
       }
     } catch (error) {
-      record.state = "error";
-      const wrapped = new ModuleCompileError(record.id, error);
-      emitError(record, "transform", wrapped);
-      throw wrapped;
+      if (record.state !== "error") {
+        record.state = "error";
+        emitError(record, error instanceof ModuleResolutionError ? "resolve" : "link", error);
+      }
+      throw error;
     }
 
-    record.url = moduleUrlBackend.create(appendSourceUrl(record.compiledCode, record.id));
+    try {
+      record.url = moduleUrlBackend.create(appendSourceUrl(record.compiledCode, record.id));
+    } catch (error) {
+      record.state = "error";
+      emitError(record, "url-create", error);
+      throw error;
+    }
     record.state = "compiled";
     emit({
       type: "module-compiled",
@@ -597,30 +672,69 @@ export function createRuntime(options = {}) {
       );
     }
 
-    record.url = moduleUrlBackend.create(appendSourceUrl(lines.join("\n"), `host:${record.id}`));
+    try {
+      record.url = moduleUrlBackend.create(appendSourceUrl(lines.join("\n"), `host:${record.id}`));
+    } catch (error) {
+      emitError(record, "host-bridge", error);
+      throw error;
+    }
     return record.url;
   }
 
   function resolveSpecifier(specifier, importer) {
     const raw = String(specifier);
+    emit({
+      type: "module-resolving",
+      specifier: raw,
+      importer: importer ?? null,
+    });
 
-    if (typeof customResolve === "function") {
-      const custom = customResolve(raw, importer, api);
-      if (typeof custom === "string" && custom) return normalizeResolved(custom, importer);
-    }
-
-    if (records.has(raw)) return raw;
-    if (isAbsoluteUrl(raw)) return raw;
+    let resolved;
+    let resolutionKind;
 
-    if (raw.startsWith("/")) return normalizePath(raw);
+    try {
+      if (typeof customResolve === "function") {
+        const custom = customResolve(raw, importer, api);
+        if (typeof custom === "string" && custom) {
+          resolved = normalizeResolved(custom, importer);
+          resolutionKind = "custom";
+        }
+      }
 
-    if (isRelativeSpecifier(raw)) {
-      if (!importer) return normalizePath(`/${raw}`);
-      if (isAbsoluteUrl(importer)) return new URL(raw, importer).href;
-      return normalizePath(`${dirname(importer)}/${raw}`);
+      if (resolved == null && records.has(raw)) {
+        resolved = raw;
+        resolutionKind = "registered";
+      }
+      if (resolved == null && isAbsoluteUrl(raw)) {
+        resolved = raw;
+        resolutionKind = "url";
+      }
+      if (resolved == null && raw.startsWith("/")) {
+        resolved = normalizePath(raw);
+        resolutionKind = "absolute";
+      }
+      if (resolved == null && isRelativeSpecifier(raw)) {
+        if (!importer) resolved = normalizePath(`/${raw}`);
+        else if (isAbsoluteUrl(importer)) resolved = new URL(raw, importer).href;
+        else resolved = normalizePath(`${dirname(importer)}/${raw}`);
+        resolutionKind = "relative";
+      }
+      if (resolved == null) {
+        resolved = raw;
+        resolutionKind = "native";
+      }
+    } catch (error) {
+      throw error;
     }
 
-    return raw;
+    emit({
+      type: "module-resolved",
+      specifier: raw,
+      importer: importer ?? null,
+      resolvedId: resolved,
+      resolutionKind,
+    });
+    return resolved;
   }
 
   function syncDependencyEdges(record, nextDependencies) {
@@ -642,7 +756,7 @@ export function createRuntime(options = {}) {
   }
 
   function emit(event) {
-    if (subscribers.size === 0) return;
+    if (events.size === 0) return;
     const payload = {
       runtimeId,
       timestamp: Date.now(),
@@ -652,23 +766,13 @@ export function createRuntime(options = {}) {
       eventBuffer.push(payload);
       return;
     }
-    dispatchEvent(payload);
+    events.emit(payload);
   }
 
   function flushEventBuffer() {
     if (eventBuffer.length === 0) return;
     const pending = eventBuffer.splice(0, eventBuffer.length);
-    for (const event of pending) dispatchEvent(event);
-  }
-
-  function dispatchEvent(payload) {
-    for (const listener of [...subscribers]) {
-      try {
-        listener(payload);
-      } catch (error) {
-        globalThis.console?.error?.("solid-tag-runtime lifecycle subscriber error", error);
-      }
-    }
+    for (const event of pending) events.emit(event);
   }
 
   function emitError(record, phase, error) {