solid-tag-runtime 0.0.11 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-tag-runtime",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Runtime module system for JSX modules compiled with solid-tag and executed through @solidjs/html",
   "type": "module",
   "exports": {
@@ -33,11 +33,13 @@
     "index.d.ts",
     "html.d.ts",
     "README.md",
-    "ARCHITECTURE.md"
+    "ARCHITECTURE.md",
+    "docs",
+    "examples"
   ],
   "sideEffects": false,
   "dependencies": {
-    "solid-tag": "^0.0.1"
+    "solid-tag": "0.0.1"
   },
   "scripts": {
     "test": "node ./test/run.mjs",

package/src/compile-cache.js

@@ -0,0 +1,340 @@
+const DEFAULT_LOCAL_STORAGE_PREFIX = "solid-tag-runtime:compile-cache:";
+const DEFAULT_IDB_DATABASE = "solid-tag-runtime-compile-cache";
+const DEFAULT_IDB_STORE = "artifacts";
+
+export function createMemoryCompileCache(options = {}) {
+  const records = options.records instanceof Map ? options.records : new Map();
+
+  return {
+    kind: "memory",
+    async get(key) {
+      return records.get(String(key));
+    },
+    async set(key, value) {
+      records.set(String(key), cloneValue(value));
+    },
+    async delete(key) {
+      return records.delete(String(key));
+    },
+    async clear(options = {}) {
+      const prefix = options.prefix == null ? null : String(options.prefix);
+      if (prefix == null) {
+        const count = records.size;
+        records.clear();
+        return count;
+      }
+      let count = 0;
+      for (const key of [...records.keys()]) {
+        if (key.startsWith(prefix)) {
+          records.delete(key);
+          count += 1;
+        }
+      }
+      return count;
+    },
+    async entries(options = {}) {
+      const prefix = options.prefix == null ? null : String(options.prefix);
+      const result = [];
+      for (const [key, value] of records) {
+        if (prefix == null || key.startsWith(prefix)) result.push([key, cloneValue(value)]);
+      }
+      return result;
+    },
+  };
+}
+
+export function createLocalStorageCompileCache(options = {}) {
+  const prefix = String(options.prefix ?? DEFAULT_LOCAL_STORAGE_PREFIX);
+  const configuredStorage = options.storage;
+
+  function assertStorage() {
+    let storage = configuredStorage;
+    if (!storage) {
+      try { storage = globalThis.localStorage; } catch (error) { throw error; }
+    }
+    if (!storage || typeof storage.getItem !== "function") {
+      throw new Error("localStorage is unavailable in this environment.");
+    }
+    return storage;
+  }
+
+  const physical = key => `${prefix}${String(key)}`;
+  const logical = key => String(key).slice(prefix.length);
+
+  return {
+    kind: "localstorage",
+    async get(key) {
+      const raw = assertStorage().getItem(physical(key));
+      return raw == null ? undefined : JSON.parse(raw);
+    },
+    async set(key, value) {
+      assertStorage().setItem(physical(key), JSON.stringify(value));
+    },
+    async delete(key) {
+      const target = physical(key);
+      const store = assertStorage();
+      const existed = store.getItem(target) != null;
+      store.removeItem(target);
+      return existed;
+    },
+    async clear(options = {}) {
+      const store = assertStorage();
+      const logicalPrefix = options.prefix == null ? "" : String(options.prefix);
+      const targetPrefix = physical(logicalPrefix);
+      const keys = [];
+      for (let index = 0; index < store.length; index += 1) {
+        const key = store.key(index);
+        if (key != null && key.startsWith(targetPrefix)) keys.push(key);
+      }
+      for (const key of keys) store.removeItem(key);
+      return keys.length;
+    },
+    async entries(options = {}) {
+      const store = assertStorage();
+      const logicalPrefix = options.prefix == null ? "" : String(options.prefix);
+      const targetPrefix = physical(logicalPrefix);
+      const result = [];
+      for (let index = 0; index < store.length; index += 1) {
+        const key = store.key(index);
+        if (key == null || !key.startsWith(targetPrefix)) continue;
+        const raw = store.getItem(key);
+        if (raw == null) continue;
+        result.push([logical(key), JSON.parse(raw)]);
+      }
+      return result;
+    },
+  };
+}
+
+export function createIndexedDBCompileCache(options = {}) {
+  const database = String(options.database ?? DEFAULT_IDB_DATABASE);
+  const storeName = String(options.storeName ?? DEFAULT_IDB_STORE);
+  const databaseVersion = Number(options.databaseVersion ?? 1);
+  const indexedDBFactory = options.indexedDB ?? globalThis.indexedDB;
+  let dbPromise;
+
+  function openDatabase() {
+    if (dbPromise) return dbPromise;
+    if (!indexedDBFactory || typeof indexedDBFactory.open !== "function") {
+      return Promise.reject(new Error("IndexedDB is unavailable in this environment."));
+    }
+
+    dbPromise = new Promise((resolve, reject) => {
+      const request = indexedDBFactory.open(database, databaseVersion);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => {
+        dbPromise = undefined;
+        reject(request.error ?? new Error(`Failed to open IndexedDB database ${database}.`));
+      };
+      request.onblocked = () => {
+        dbPromise = undefined;
+        reject(new Error(`Opening IndexedDB database ${database} was blocked.`));
+      };
+    });
+
+    return dbPromise;
+  }
+
+
+
+  return {
+    kind: "indexeddb",
+    async get(key) {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readonly");
+        const request = tx.objectStore(storeName).get(String(key));
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cache read failed."));
+      });
+    },
+    async set(key, value) {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        tx.objectStore(storeName).put(value, String(key));
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error ?? new Error("IndexedDB cache write failed."));
+        tx.onabort = () => reject(tx.error ?? new Error("IndexedDB cache write was aborted."));
+      });
+    },
+    async delete(key) {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        const lookup = store.getKey(String(key));
+        let existed = false;
+        lookup.onsuccess = () => {
+          existed = lookup.result !== undefined;
+          store.delete(String(key));
+        };
+        lookup.onerror = () => reject(lookup.error ?? new Error("IndexedDB cache delete lookup failed."));
+        tx.oncomplete = () => resolve(existed);
+        tx.onerror = () => reject(tx.error ?? new Error("IndexedDB cache delete failed."));
+        tx.onabort = () => reject(tx.error ?? new Error("IndexedDB cache delete was aborted."));
+      });
+    },
+    async clear(options = {}) {
+      const prefix = options.prefix == null ? null : String(options.prefix);
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        if (prefix == null || prefix === "") {
+          const countRequest = store.count();
+          let count = 0;
+          countRequest.onsuccess = () => { count = countRequest.result; };
+          store.clear();
+          tx.oncomplete = () => resolve(count);
+          tx.onerror = () => reject(tx.error ?? new Error("IndexedDB cache clear failed."));
+          tx.onabort = () => reject(tx.error ?? new Error("IndexedDB cache clear was aborted."));
+          return;
+        }
+
+        let count = 0;
+        const request = store.openCursor();
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) return;
+          if (String(cursor.key).startsWith(prefix)) {
+            cursor.delete();
+            count += 1;
+          }
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cache clear cursor failed."));
+        tx.oncomplete = () => resolve(count);
+        tx.onerror = () => reject(tx.error ?? new Error("IndexedDB cache clear failed."));
+        tx.onabort = () => reject(tx.error ?? new Error("IndexedDB cache clear was aborted."));
+      });
+    },
+    async entries(options = {}) {
+      const prefix = options.prefix == null ? null : String(options.prefix);
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readonly");
+        const request = tx.objectStore(storeName).openCursor();
+        const result = [];
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) return;
+          const key = String(cursor.key);
+          if (prefix == null || key.startsWith(prefix)) result.push([key, cursor.value]);
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error ?? new Error("IndexedDB cache entries cursor failed."));
+        tx.oncomplete = () => resolve(result);
+        tx.onerror = () => reject(tx.error ?? new Error("IndexedDB cache entries transaction failed."));
+      });
+    },
+  };
+}
+
+export async function sha256(value) {
+  const bytes = new TextEncoder().encode(String(value));
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle) {
+    const digest = await subtle.digest("SHA-256", bytes);
+    return toHex(new Uint8Array(digest));
+  }
+  return sha256Fallback(bytes);
+}
+
+export function stableSerialize(value) {
+  return JSON.stringify(normalize(value));
+}
+
+export function approximateByteSize(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalize(value) {
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  if (Array.isArray(value)) return value.map(normalize);
+  if (typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value).sort()) {
+      const item = value[key];
+      if (item === undefined) continue;
+      result[key] = normalize(item);
+    }
+    return result;
+  }
+  return String(value);
+}
+
+function toHex(bytes) {
+  return [...bytes].map(byte => byte.toString(16).padStart(2, "0")).join("");
+}
+
+function sha256Fallback(bytes) {
+  const K = [
+    0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
+    0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
+    0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
+    0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
+    0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
+    0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
+    0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
+    0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2,
+  ];
+  const H = [0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19];
+  const bitLength = bytes.length * 8;
+  const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+  const data = new Uint8Array(paddedLength);
+  data.set(bytes);
+  data[bytes.length] = 0x80;
+  const view = new DataView(data.buffer);
+  const high = Math.floor(bitLength / 0x100000000);
+  const low = bitLength >>> 0;
+  view.setUint32(paddedLength - 8, high, false);
+  view.setUint32(paddedLength - 4, low, false);
+  const w = new Uint32Array(64);
+
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i += 1) w[i] = view.getUint32(offset + i * 4, false);
+    for (let i = 16; i < 64; i += 1) {
+      const a = w[i - 15];
+      const b = w[i - 2];
+      const s0 = rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3);
+      const s1 = rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+    }
+    let [a,b,c,d,e,f,g,h] = H;
+    for (let i = 0; i < 64; i += 1) {
+      const S1 = rotr(e,6) ^ rotr(e,11) ^ rotr(e,25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (h + S1 + ch + K[i] + w[i]) >>> 0;
+      const S0 = rotr(a,2) ^ rotr(a,13) ^ rotr(a,22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (S0 + maj) >>> 0;
+      h=g; g=f; f=e; e=(d+t1)>>>0; d=c; c=b; b=a; a=(t1+t2)>>>0;
+    }
+    H[0]=(H[0]+a)>>>0; H[1]=(H[1]+b)>>>0; H[2]=(H[2]+c)>>>0; H[3]=(H[3]+d)>>>0;
+    H[4]=(H[4]+e)>>>0; H[5]=(H[5]+f)>>>0; H[6]=(H[6]+g)>>>0; H[7]=(H[7]+h)>>>0;
+  }
+  const output = new Uint8Array(32);
+  const out = new DataView(output.buffer);
+  H.forEach((value, index) => out.setUint32(index * 4, value, false));
+  return toHex(output);
+}
+
+function rotr(value, bits) {
+  return (value >>> bits) | (value << (32 - bits));
+}
+
+function cloneValue(value) {
+  if (typeof structuredClone === "function") {
+    try { return structuredClone(value); } catch {}
+  }
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

package/src/compiler.js

@@ -1,4 +1,7 @@
 import { parseJSX, transformModule } from "solid-tag";
+import { stableSerialize } from "./compile-cache.js";
+
+const DEFAULT_COMPILER_ABI = "solid-tag-runtime:solid-tag@0.0.1:compiler:v1";
 
 export function createSolidTagCompiler(options = {}) {
   const {
@@ -6,45 +9,11 @@ export function createSolidTagCompiler(options = {}) {
     transformOptions = {},
   } = options;
 
-  return {
-    analyze(source) {
-      const ast = parseJSX(source);
-      const imports = [];
-      let needsHtmlRuntime = false;
-      walk(ast, node => {
-        if (node.type === "JSXElement" || node.type === "JSXFragment") needsHtmlRuntime = true;
-        if (
-          (node.type === "ImportDeclaration" ||
-            node.type === "ExportNamedDeclaration" ||
-            node.type === "ExportAllDeclaration") &&
-          node.source &&
-          typeof node.source.value === "string"
-        ) {
-          imports.push({
-            specifier: node.source.value,
-            start: node.source.start,
-            end: node.source.end,
-            kind: node.type,
-          });
-          return;
-        }
-
-        if (
-          node.type === "ImportExpression" &&
-          node.source &&
-          (node.source.type === "Literal" || node.source.type === "StringLiteral") &&
-          typeof node.source.value === "string"
-        ) {
-          imports.push({
-            specifier: node.source.value,
-            start: node.source.start,
-            end: node.source.end,
-            kind: "ImportExpression",
-          });
-        }
-      });
+  const compiler = {
+    fingerprint: `${DEFAULT_COMPILER_ABI}:${stableSerialize({ tag, transformOptions })}`,
 
-      return { imports, needsHtmlRuntime };
+    analyze(source) {
+      return analyzeSource(source);
     },
 
     transform(source, context = {}) {
@@ -52,10 +21,89 @@ export function createSolidTagCompiler(options = {}) {
         ...transformOptions,
         tag,
         injectHtmlImport: true,
+        // Keep this unresolved in the persistent artifact. Runtime-specific
+        // host/native resolution happens later in the linker.
         htmlImportSource: context.htmlImportSource ?? "@solidjs/html",
       });
     },
+
+    compile(source, context = {}) {
+      let code;
+      let diagnostics = [];
+      let changed = false;
+      let sourceMap;
+
+      if (context.format === "js") {
+        code = source;
+      } else {
+        const transformed = compiler.transform(source, {
+          ...context,
+          htmlImportSource: "@solidjs/html",
+        });
+        code = transformed.code;
+        diagnostics = [...(transformed.diagnostics ?? [])];
+        changed = Boolean(transformed.changed);
+        sourceMap = transformed.sourceMap;
+      }
+
+      const analysis = analyzeSource(code);
+      return {
+        schema: 1,
+        code,
+        imports: analysis.imports,
+        diagnostics,
+        changed,
+        ...(sourceMap == null ? {} : { sourceMap }),
+      };
+    },
   };
+
+  return compiler;
+}
+
+function analyzeSource(source) {
+  const ast = parseJSX(source);
+  const imports = [];
+  let needsHtmlRuntime = false;
+  walk(ast, node => {
+    if (node.type === "JSXElement" || node.type === "JSXFragment") needsHtmlRuntime = true;
+    if (
+      (node.type === "ImportDeclaration" ||
+        node.type === "ExportNamedDeclaration" ||
+        node.type === "ExportAllDeclaration") &&
+      node.source &&
+      typeof node.source.value === "string"
+    ) {
+      imports.push({
+        specifier: node.source.value,
+        start: node.source.start,
+        end: node.source.end,
+        kind: normalizeImportKind(node.type),
+      });
+      return;
+    }
+
+    if (
+      node.type === "ImportExpression" &&
+      node.source &&
+      (node.source.type === "Literal" || node.source.type === "StringLiteral") &&
+      typeof node.source.value === "string"
+    ) {
+      imports.push({
+        specifier: node.source.value,
+        start: node.source.start,
+        end: node.source.end,
+        kind: "dynamic",
+      });
+    }
+  });
+
+  return { imports, needsHtmlRuntime };
+}
+
+function normalizeImportKind(type) {
+  if (type === "ExportNamedDeclaration" || type === "ExportAllDeclaration") return "export";
+  return "static";
 }
 
 function walk(node, visit) {