solid-tag-runtime 0.0.13 → 0.0.15

package/src/solid/integration.js

@@ -0,0 +1,30 @@
+import { ensureDocumentDelegationHost } from "../html/delegation-host.js";
+import { ensureDelegatedEvents } from "../html/delegated-events.js";
+
+const integrations = new WeakMap();
+
+export function installSolidRuntimeIntegration(runtime, modules, options = {}) {
+  if (!runtime || (typeof runtime !== "object" && typeof runtime !== "function")) {
+    throw new TypeError("installSolidRuntimeIntegration() requires a runtime object.");
+  }
+  const web = modules?.["@solidjs/web"];
+  if (!web) {
+    throw new TypeError("Solid runtime integration requires the @solidjs/web host module.");
+  }
+
+  const integration = {
+    modules,
+    web,
+    ensureDelegation(document) {
+      const host = ensureDocumentDelegationHost(web, document);
+      ensureDelegatedEvents(web, document, options.delegatedEvents);
+      return host;
+    },
+  };
+  integrations.set(runtime, integration);
+  return integration;
+}
+
+export function getSolidRuntimeIntegration(runtime) {
+  return integrations.get(runtime);
+}

package/src/solid/packages.js

@@ -0,0 +1,24 @@
+export const SOLID_RUNTIME_PACKAGES = Object.freeze([
+  "solid-js",
+  "@solidjs/web",
+  "@solidjs/html",
+  "@solidjs/signals",
+]);
+
+// Keep CDN fallback deterministic. This runtime release is tested against the
+// coordinated Solid 2 RC family below rather than provider "latest" tags.
+export const TESTED_SOLID_VERSION = "2.0.0-rc.13";
+
+export function isSolidRuntimePackage(value) {
+  return SOLID_RUNTIME_PACKAGES.includes(String(value));
+}
+
+export function pickSolidRuntimeModules(modules = {}) {
+  const picked = {};
+  for (const packageName of SOLID_RUNTIME_PACKAGES) {
+    if (Object.prototype.hasOwnProperty.call(modules, packageName)) {
+      picked[packageName] = modules[packageName];
+    }
+  }
+  return picked;
+}

package/src/solid/providers/esm-sh.js

@@ -0,0 +1,81 @@
+const HOSTS = new Set(["esm.sh", "www.esm.sh"]);
+
+export const esmShProvider = {
+  id: "esm.sh",
+
+  matches(value) {
+    const url = toURL(value);
+    return Boolean(url && HOSTS.has(url.hostname));
+  },
+
+  inspect(value) {
+    const url = toURL(value);
+    if (!url || !HOSTS.has(url.hostname)) return {};
+    const parsed = parsePackagePath(url.pathname);
+    return {
+      provider: "esm.sh",
+      packageName: parsed.packageName,
+      version: parsed.version,
+      url: url.href,
+    };
+  },
+
+  createPackageUrl(packageName, context = {}) {
+    const version = context.version;
+    const base = new URL(`https://esm.sh/${packageName}${version ? `@${version}` : ""}`);
+    const authoritative = context.authoritativeMappings ?? new Map();
+    const external = [];
+    const deps = [];
+
+    for (const dependency of solidFamilyDependencyClosure(packageName)) {
+      if (authoritative.has(dependency)) {
+        // Preserve the page's exact identity anchor. esm.sh leaves this bare so
+        // the browser/import map resolves the already-authoritative package.
+        external.push(dependency);
+      } else if (version) {
+        // With no page-owned anchor, pin coordinated sibling dependencies so
+        // separately generated package URLs converge on one provider version.
+        deps.push(`${dependency}@${version}`);
+      }
+    }
+
+    // Explicit mappings for other family members are also authoritative when a
+    // generated package happens to import them.
+    for (const [name] of authoritative) {
+      if (name === packageName || external.includes(name)) continue;
+      if (!context.familyPackages?.includes?.(name)) continue;
+      external.push(name);
+    }
+
+    if (external.length) base.searchParams.set("external", external.join(","));
+    if (deps.length) base.searchParams.set("deps", deps.join(","));
+    return base.href;
+  },
+};
+
+function parsePackagePath(pathname) {
+  const value = decodeURIComponent(String(pathname ?? "")).replace(/^\/+/, "");
+  const match = value.match(/^(@[^/]+\/[^@/?]+|[^@/?]+)(?:@([^/?]+))?/);
+  if (!match) return {};
+  return { packageName: match[1], version: match[2] };
+}
+
+function toURL(value) {
+  try {
+    return new URL(String(value));
+  } catch {
+    return undefined;
+  }
+}
+
+function solidFamilyDependencyClosure(packageName) {
+  // Solid 2's reactive core is @solidjs/signals. solid-js consumes it,
+  // @solidjs/web consumes solid-js, and @solidjs/html consumes @solidjs/web.
+  // Include the family closure rather than only direct package dependencies so
+  // provider-generated URLs cannot silently pick a second reactive-core copy.
+  if (packageName === "solid-js") return ["@solidjs/signals"];
+  if (packageName === "@solidjs/web") return ["solid-js", "@solidjs/signals"];
+  if (packageName === "@solidjs/html") return ["@solidjs/web", "solid-js", "@solidjs/signals"];
+  if (packageName === "@solidjs/signals") return [];
+  return [];
+}

package/src/solid/providers/index.js

@@ -0,0 +1,22 @@
+import { esmShProvider } from "./esm-sh.js";
+import { jsDelivrProvider } from "./jsdelivr.js";
+
+export const SOLID_MODULE_PROVIDERS = Object.freeze([
+  esmShProvider,
+  jsDelivrProvider,
+]);
+
+export function getSolidModuleProvider(id) {
+  const normalized = normalizeProviderId(id);
+  return SOLID_MODULE_PROVIDERS.find(provider => provider.id === normalized);
+}
+
+export function matchSolidModuleProvider(url) {
+  return SOLID_MODULE_PROVIDERS.find(provider => provider.matches(url));
+}
+
+export function normalizeProviderId(value) {
+  if (value === "esm.sh" || value === "esm") return "esm.sh";
+  if (value === "jsdelivr" || value === "jsDelivr") return "jsdelivr";
+  return value == null ? undefined : String(value);
+}

package/src/solid/providers/jsdelivr.js

@@ -0,0 +1,45 @@
+const HOSTS = new Set(["cdn.jsdelivr.net", "fastly.jsdelivr.net"]);
+
+export const jsDelivrProvider = {
+  id: "jsdelivr",
+
+  matches(value) {
+    const url = toURL(value);
+    return Boolean(url && HOSTS.has(url.hostname) && url.pathname.includes("/npm/"));
+  },
+
+  inspect(value) {
+    const url = toURL(value);
+    if (!url || !HOSTS.has(url.hostname)) return {};
+    const marker = "/npm/";
+    const index = url.pathname.indexOf(marker);
+    if (index < 0) return {};
+    const parsed = parsePackagePath(url.pathname.slice(index + marker.length));
+    return {
+      provider: "jsdelivr",
+      packageName: parsed.packageName,
+      version: parsed.version,
+      url: url.href,
+    };
+  },
+
+  createPackageUrl(packageName, context = {}) {
+    const version = context.version;
+    return `https://cdn.jsdelivr.net/npm/${packageName}${version ? `@${version}` : ""}/+esm`;
+  },
+};
+
+function parsePackagePath(pathname) {
+  const value = decodeURIComponent(String(pathname ?? "")).replace(/^\/+/, "");
+  const match = value.match(/^(@[^/]+\/[^@/?]+|[^@/?]+)(?:@([^/?]+))?/);
+  if (!match) return {};
+  return { packageName: match[1], version: match[2] };
+}
+
+function toURL(value) {
+  try {
+    return new URL(String(value));
+  } catch {
+    return undefined;
+  }
+}

package/src/solid/resolve.js

@@ -0,0 +1,287 @@
+import { readImportMapImports } from "./import-map.js";
+import {
+  SOLID_RUNTIME_PACKAGES,
+  TESTED_SOLID_VERSION,
+  isSolidRuntimePackage,
+} from "./packages.js";
+import {
+  getSolidModuleProvider,
+  matchSolidModuleProvider,
+  normalizeProviderId,
+} from "./providers/index.js";
+
+export class SolidModuleResolutionError extends Error {
+  constructor(message, details = {}) {
+    super(message);
+    this.name = "SolidModuleResolutionError";
+    Object.assign(this, details);
+  }
+}
+
+export async function loadSolidModulesWithEnvironment(options = {}, environment = createDefaultSolidEnvironment()) {
+  const source = normalizeSource(options.source);
+  const modules = Object.create(null);
+  const resolvedSpecifiers = new Map();
+  const authoritativeMappings = new Map();
+  const failures = new Map();
+  const unknownHostNamespaces = new Set();
+  const pageMappings = readImportMapImports(options.document ?? environment.document);
+
+  for (const packageName of SOLID_RUNTIME_PACKAGES) {
+    if (Object.prototype.hasOwnProperty.call(options.modules ?? {}, packageName)) {
+      modules[packageName] = options.modules[packageName];
+    }
+    const explicit = options.specifiers?.[packageName];
+    if (typeof explicit === "string" && explicit) {
+      resolvedSpecifiers.set(packageName, explicit);
+      authoritativeMappings.set(packageName, explicit);
+      continue;
+    }
+    const mapped = pageMappings.get(packageName);
+    if (mapped) {
+      // Keep the browser/import map authoritative. Importing the bare package
+      // also handles relative map targets correctly against the document base.
+      resolvedSpecifiers.set(packageName, packageName);
+      authoritativeMappings.set(packageName, mapped);
+    }
+  }
+
+  // Discover the browser/bundler's effective resolution without overriding
+  // explicit mappings. This is advisory; dynamic import remains authoritative.
+  if (source === "auto" || source === "host") {
+    for (const packageName of SOLID_RUNTIME_PACKAGES) {
+      if (modules[packageName] || resolvedSpecifiers.has(packageName)) continue;
+      try {
+        const resolved = await environment.resolve?.(packageName);
+        if (typeof resolved === "string" && resolved && resolved !== packageName) {
+          resolvedSpecifiers.set(packageName, resolved);
+          authoritativeMappings.set(packageName, resolved);
+        }
+      } catch {
+        // Import may still work in a bundler even when import.meta.resolve does not.
+      }
+    }
+  }
+
+  // Import everything the host already knows how to resolve. Existing exact
+  // URLs are used verbatim, preserving page-owned import-map identity.
+  for (const packageName of SOLID_RUNTIME_PACKAGES) {
+    if (modules[packageName]) continue;
+    const specifier = resolvedSpecifiers.get(packageName);
+    if (!specifier) continue;
+    try {
+      modules[packageName] = await environment.importModule(specifier);
+    } catch (error) {
+      failures.set(packageName, error);
+    }
+  }
+
+  // A bundler may resolve bare dynamic imports even when import.meta.resolve is
+  // unavailable. Try that path in host/auto modes before considering a CDN.
+  if (source === "auto" || source === "host") {
+    for (const packageName of SOLID_RUNTIME_PACKAGES) {
+      if (modules[packageName]) continue;
+      try {
+        modules[packageName] = await environment.importModule(packageName);
+        let anchored = authoritativeMappings.has(packageName);
+        try {
+          const resolved = await environment.resolve?.(packageName);
+          if (typeof resolved === "string" && resolved && resolved !== packageName) {
+            resolvedSpecifiers.set(packageName, resolved);
+            authoritativeMappings.set(packageName, resolved);
+            anchored = true;
+          }
+        } catch {
+          // A complete host-resolved family needs no provider fallback.
+        }
+        if (!anchored) unknownHostNamespaces.add(packageName);
+      } catch (error) {
+        failures.set(packageName, error);
+      }
+    }
+  }
+
+  let missing = SOLID_RUNTIME_PACKAGES.filter(packageName => !modules[packageName]);
+  if (!missing.length) return freezeModuleFamily(modules);
+
+  if (source === "host") {
+    throw createResolutionFailure({ source, missing, failures, authoritativeMappings });
+  }
+
+  if (source === "auto" && unknownHostNamespaces.size) {
+    throw createResolutionFailure({
+      source,
+      missing,
+      failures,
+      authoritativeMappings,
+      hint: `Refusing to mix CDN fallback with host-resolved Solid modules whose identity is opaque (${[...unknownHostNamespaces].join(", ")}). Provide the remaining Solid namespaces/specifiers explicitly or make the host mapping resolvable.`,
+    });
+  }
+
+  const strongAnchor = findStrongAnchor(authoritativeMappings);
+  let providerId = source === "esm.sh" || source === "jsdelivr"
+    ? normalizeProviderId(source)
+    : strongAnchor?.provider?.id;
+  if (!providerId) providerId = inferWeakProvider(pageMappings)?.id;
+  if (!providerId) providerId = normalizeProviderId(options.fallbackProvider);
+  if (!providerId) {
+    throw createResolutionFailure({
+      source,
+      missing,
+      failures,
+      authoritativeMappings,
+      hint: "Configure `fallbackProvider`/`version`, provide explicit module namespaces, or add resolvable Solid import-map entries.",
+    });
+  }
+
+  const provider = getSolidModuleProvider(providerId);
+  if (!provider) {
+    throw new SolidModuleResolutionError(`Unknown Solid module provider ${JSON.stringify(providerId)}.`, {
+      provider: providerId,
+      missing,
+    });
+  }
+
+  const version = selectVersion(options, strongAnchor);
+  validateProviderMix(provider, strongAnchor, authoritativeMappings, missing);
+
+  for (const packageName of missing) {
+    const existing = authoritativeMappings.get(packageName);
+    const specifier = existing ?? provider.createPackageUrl(packageName, {
+      version,
+      authoritativeMappings,
+      familyPackages: SOLID_RUNTIME_PACKAGES,
+    });
+    resolvedSpecifiers.set(packageName, specifier);
+    try {
+      modules[packageName] = await environment.importModule(specifier);
+    } catch (error) {
+      failures.set(packageName, error);
+    }
+  }
+
+  missing = SOLID_RUNTIME_PACKAGES.filter(packageName => !modules[packageName]);
+  if (missing.length) {
+    throw createResolutionFailure({
+      source,
+      provider: provider.id,
+      version,
+      missing,
+      failures,
+      authoritativeMappings,
+    });
+  }
+
+  return freezeModuleFamily(modules);
+}
+
+export function createDefaultSolidEnvironment() {
+  return {
+    document: globalThis.document,
+    async resolve(specifier) {
+      if (typeof import.meta.resolve !== "function") return undefined;
+      return import.meta.resolve(specifier);
+    },
+    importModule(specifier) {
+      return import(specifier);
+    },
+  };
+}
+
+export function inspectSolidResolution(options = {}) {
+  const pageMappings = readImportMapImports(options.document ?? globalThis.document);
+  const authoritativeMappings = new Map();
+  for (const packageName of SOLID_RUNTIME_PACKAGES) {
+    const explicit = options.specifiers?.[packageName];
+    const mapped = explicit ?? pageMappings.get(packageName);
+    if (mapped) authoritativeMappings.set(packageName, mapped);
+  }
+  const strongAnchor = findStrongAnchor(authoritativeMappings);
+  return {
+    pageMappings,
+    authoritativeMappings,
+    provider: strongAnchor?.provider?.id ?? inferWeakProvider(pageMappings)?.id,
+    version: strongAnchor?.version,
+  };
+}
+
+function normalizeSource(value) {
+  const source = value ?? "auto";
+  if (source === "auto" || source === "host" || source === "esm.sh" || source === "jsdelivr") return source;
+  throw new TypeError(`Unknown Solid module source ${JSON.stringify(source)}.`);
+}
+
+function findStrongAnchor(authoritativeMappings) {
+  const ordered = ["solid-js", ...SOLID_RUNTIME_PACKAGES.filter(name => name !== "solid-js")];
+  for (const packageName of ordered) {
+    const url = authoritativeMappings.get(packageName);
+    if (!url) continue;
+    const provider = matchSolidModuleProvider(url);
+    if (!provider) continue;
+    const inspected = provider.inspect(url);
+    return {
+      packageName,
+      url,
+      provider,
+      version: inspected.version,
+    };
+  }
+  return undefined;
+}
+
+function inferWeakProvider(pageMappings) {
+  for (const [, target] of pageMappings) {
+    const provider = matchSolidModuleProvider(target);
+    if (provider) return provider;
+  }
+  return undefined;
+}
+
+function selectVersion(options, strongAnchor) {
+  if (strongAnchor?.version) return strongAnchor.version;
+  if (options.version) return String(options.version);
+  if (strongAnchor) return undefined; // Preserve an explicitly unversioned family anchor.
+  return TESTED_SOLID_VERSION;
+}
+
+function validateProviderMix(provider, strongAnchor, authoritativeMappings, missing) {
+  if (!missing.length || provider.id !== "jsdelivr") return;
+  const incompatible = Array.from(authoritativeMappings.entries())
+    .filter(([packageName, target]) => isSolidRuntimePackage(packageName) && !provider.matches(target));
+  if (!incompatible.length) return;
+  throw new SolidModuleResolutionError(
+    "Cannot safely generate jsDelivr Solid sibling packages while one or more Solid-family packages are mapped through another/custom provider. Provide the full Solid family explicitly or use a provider that can externalize the authoritative mappings.",
+    {
+      provider: provider.id,
+      anchor: strongAnchor,
+      missing,
+      incompatibleMappings: incompatible,
+    },
+  );
+}
+
+function createResolutionFailure({ source, provider, version, missing, failures, authoritativeMappings, hint }) {
+  const details = missing.map(packageName => {
+    const error = failures.get(packageName);
+    return `${packageName}${error ? ` (${error?.message ?? String(error)})` : ""}`;
+  }).join(", ");
+  const mappingText = authoritativeMappings.size
+    ? ` Existing Solid mappings: ${Array.from(authoritativeMappings, ([key, value]) => `${key}=${value}`).join(", ")}.`
+    : "";
+  const providerText = provider ? ` Provider: ${provider}${version ? `@${version}` : ""}.` : "";
+  return new SolidModuleResolutionError(
+    `Could not resolve a coherent Solid runtime module family. Missing: ${details}.${providerText}${mappingText}${hint ? ` ${hint}` : ""}`,
+    { source, provider, version, missing, failures, authoritativeMappings },
+  );
+}
+
+function freezeModuleFamily(modules) {
+  const result = {};
+  for (const packageName of SOLID_RUNTIME_PACKAGES) {
+    if (!modules[packageName]) {
+      throw new SolidModuleResolutionError(`Solid module family is incomplete; missing ${JSON.stringify(packageName)}.`);
+    }
+    result[packageName] = modules[packageName];
+  }
+  return Object.freeze(result);
+}