@hyperspan/framework 2.0.0-alpha.7 → 2.0.1

package/dist/ssr/mock-dom.js

@@ -0,0 +1,370 @@
+const MOCK_DOM_MARK = "__hyperspan_mock_dom";
+function markedMockDocument(d) {
+  return Boolean(
+    d && typeof d === "object" && d[MOCK_DOM_MARK] === true
+  );
+}
+function stubElement(tag) {
+  const children = [];
+  const node = {
+    tagName: String(tag).toUpperCase(),
+    nodeType: 1,
+    nodeName: String(tag).toLowerCase(),
+    id: "",
+    className: "",
+    textContent: "",
+    innerHTML: "",
+    childNodes: children,
+    get children() {
+      return children;
+    },
+    style: {},
+    dataset: {},
+    parentNode: null,
+    parentElement: null,
+    classList: {
+      contains: () => false,
+      add() {
+      },
+      remove() {
+      },
+      toggle() {
+        return false;
+      }
+    },
+    appendChild(child) {
+      children.push(child);
+      child.parentNode = node;
+      child.parentElement = node;
+      return child;
+    },
+    insertBefore(child, ref) {
+      const ch = node.childNodes;
+      const refIx = ref == null ? -1 : ch.indexOf(ref);
+      if (refIx < 0) children.push(child);
+      else children.splice(refIx, 0, child);
+      child.parentNode = node;
+      child.parentElement = node;
+      return child;
+    },
+    removeChild(child) {
+      const ix = children.indexOf(child);
+      if (ix >= 0) children.splice(ix, 1);
+      const c = child;
+      c.parentElement = void 0;
+      c.parentNode = void 0;
+      return child;
+    },
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    dispatchEvent() {
+      return true;
+    },
+    setAttribute() {
+    },
+    removeAttribute() {
+    },
+    hasAttribute() {
+      return false;
+    },
+    getAttribute() {
+      return null;
+    },
+    cloneNode() {
+      return stubElement(tag);
+    },
+    getBoundingClientRect: () => ({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0,
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      toJSON() {
+        return "{}";
+      }
+    }),
+    blur() {
+    },
+    focus() {
+    },
+    click() {
+    }
+  };
+  return node;
+}
+function memoryStorage() {
+  const m = /* @__PURE__ */ new Map();
+  return {
+    get length() {
+      return m.size;
+    },
+    key(i) {
+      const keys = [...m.keys()];
+      return keys[i] ?? null;
+    },
+    clear() {
+      m.clear();
+    },
+    getItem(key) {
+      return m.get(String(key)) ?? null;
+    },
+    setItem(key, value) {
+      m.set(String(key), String(value));
+    },
+    removeItem(key) {
+      m.delete(String(key));
+    }
+  };
+}
+function installMockDom() {
+  const env = typeof process !== "undefined" ? process.env : {};
+  const disabled = env.HYPERSPAN_DISABLE_MOCK_DOM === "1" || env.HYPERSPAN_DISABLE_MOCK_DOM === "true";
+  if (disabled) return false;
+  const g = globalThis;
+  if (markedMockDocument(g.document)) return false;
+  if (typeof g.document !== "undefined" && g.document !== null && !markedMockDocument(g.document)) {
+    try {
+      const d = g.document;
+      if (d.body !== void 0 && typeof d.createElement === "function") {
+        return false;
+      }
+    } catch {
+    }
+  }
+  const htmlEl = stubElement("html");
+  const body = stubElement("body");
+  const head = stubElement("head");
+  htmlEl.appendChild(head);
+  htmlEl.appendChild(body);
+  const navigatorStub = {
+    userAgent: "HyperspanSSR/1.0",
+    language: "en-US",
+    languages: ["en-US"],
+    platform: "server",
+    onLine: true,
+    maxTouchPoints: 0
+  };
+  let rafId = 1;
+  const scheduleRaf = (cb) => {
+    queueMicrotask(() => cb(performance.now()));
+    return rafId++;
+  };
+  const win = {
+    name: "",
+    innerWidth: 1024,
+    innerHeight: 768,
+    outerWidth: 1024,
+    outerHeight: 768,
+    devicePixelRatio: 1,
+    scrollX: 0,
+    scrollY: 0,
+    scrollTo() {
+    },
+    navigator: navigatorStub,
+    localStorage: memoryStorage(),
+    sessionStorage: memoryStorage(),
+    history: {
+      length: 1,
+      state: null,
+      scrollRestoration: "auto",
+      replaceState() {
+      },
+      pushState() {
+      },
+      forward() {
+      },
+      back() {
+      },
+      go() {
+      }
+    },
+    location: new URL("http://localhost/ssr"),
+    resizeTo() {
+    },
+    resizeBy() {
+    },
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    dispatchEvent() {
+      return true;
+    },
+    alert() {
+    },
+    matchMedia(query) {
+      const media = String(query);
+      return {
+        media,
+        matches: false,
+        addListener() {
+        },
+        removeListener() {
+        },
+        addEventListener() {
+        },
+        removeEventListener() {
+        },
+        dispatchEvent() {
+          return false;
+        },
+        onchange: null
+      };
+    },
+    getComputedStyle: () => ({
+      getPropertyValue: () => "",
+      setProperty() {
+      }
+    }),
+    requestIdleCallback(cb) {
+      queueMicrotask(() => cb({ didTimeout: false, timeRemaining: () => Number.MAX_SAFE_INTEGER }));
+      return 1;
+    },
+    cancelIdleCallback() {
+    },
+    requestAnimationFrame: scheduleRaf,
+    cancelAnimationFrame() {
+    },
+    MutationObserver: typeof globalThis.MutationObserver !== "undefined" ? globalThis.MutationObserver : class {
+      constructor(_callback) {
+      }
+      disconnect() {
+      }
+      observe() {
+      }
+      takeRecords() {
+        return [];
+      }
+    },
+    IntersectionObserver: typeof globalThis.IntersectionObserver !== "undefined" ? globalThis.IntersectionObserver : class {
+      constructor(_cb, _opts) {
+      }
+      unobserve() {
+      }
+      disconnect() {
+      }
+      observe() {
+      }
+      takeRecords() {
+        return [];
+      }
+      root = null;
+      rootMargin = "";
+      thresholds = [];
+    },
+    ResizeObserver: typeof globalThis.ResizeObserver !== "undefined" ? globalThis.ResizeObserver : class {
+      constructor(_callback) {
+      }
+      disconnect() {
+      }
+      observe() {
+      }
+      unobserve() {
+      }
+    }
+  };
+  win.self = win;
+  win.window = win;
+  const documentStub = {
+    [MOCK_DOM_MARK]: true,
+    nodeType: 9,
+    defaultView: null,
+    compatibilityMode: "CSS1Compat",
+    documentElement: htmlEl,
+    body,
+    head,
+    cookie: "",
+    readyState: "complete",
+    URL: "http://localhost/ssr/",
+    referrer: "",
+    hidden: false,
+    visibilityState: "visible",
+    parentElement: null,
+    appendChild(...args) {
+      return body.appendChild(...args);
+    },
+    querySelector(sel) {
+      const s = String(sel).toLowerCase();
+      if (s === "body" || s === "html body") return body;
+      if (s === "html") return htmlEl;
+      return null;
+    },
+    querySelectorAll() {
+      return {
+        length: 0,
+        item() {
+          return null;
+        },
+        forEach() {
+        },
+        *[Symbol.iterator]() {
+        }
+      };
+    },
+    getElementById(id) {
+      const sid = String(id);
+      const e = stubElement("div");
+      e.id = sid;
+      e.getAttribute = (k) => k === "id" ? sid : null;
+      e.hasAttribute = (k) => k === "id";
+      return e;
+    },
+    getElementsByTagName() {
+      return [];
+    },
+    getElementsByClassName() {
+      return [];
+    },
+    createElement(tag) {
+      return stubElement(String(tag ?? "div"));
+    },
+    createTextNode(data) {
+      const v = String(data ?? "");
+      return { nodeType: 3, nodeValue: v, nodeName: "#text", textContent: v };
+    },
+    createDocumentFragment() {
+      const frag = {
+        nodeType: 11,
+        childNodes: [],
+        appendChild(child) {
+          frag.childNodes.push(child);
+          return child;
+        }
+      };
+      return frag;
+    },
+    elementFromPoint: () => null,
+    caretRangeFromPoint: () => null,
+    addEventListener() {
+    },
+    removeEventListener() {
+    },
+    dispatchEvent() {
+      return true;
+    }
+  };
+  documentStub.defaultView = win;
+  win.document = documentStub;
+  g.window = win;
+  g.document = documentStub;
+  try {
+    globalThis.navigator = navigatorStub;
+  } catch {
+  }
+  if (typeof globalThis.requestAnimationFrame !== "function")
+    globalThis.requestAnimationFrame = scheduleRaf;
+  if (typeof globalThis.cancelAnimationFrame !== "function")
+    globalThis.cancelAnimationFrame = (() => {
+    });
+  return true;
+}
+export {
+  MOCK_DOM_MARK,
+  installMockDom,
+  stubElement
+};

package/dist/utils.js

@@ -0,0 +1,157 @@
+function fnv1a64(input) {
+  let hash = BigInt("0xcbf29ce484222325");
+  const prime = BigInt("0x100000001b3");
+  const mask = BigInt("0xffffffffffffffff");
+  for (let i = 0; i < input.length; i++) {
+    hash ^= BigInt(input.charCodeAt(i));
+    hash = hash * prime & mask;
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+function assetHash(content) {
+  return fnv1a64(content);
+}
+function randomHash() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return fnv1a64(hex);
+}
+const ROUTE_SEGMENT_REGEX = /(\[[a-zA-Z_\.]+\])/g;
+function parsePath(urlPath) {
+  const params = [];
+  urlPath = urlPath.replace("index", "").replace(".ts", "").replace(".js", "");
+  if (urlPath.startsWith("/")) {
+    urlPath = urlPath.substring(1);
+  }
+  if (urlPath.endsWith("/")) {
+    urlPath = urlPath.substring(0, urlPath.length - 1);
+  }
+  if (!urlPath) {
+    return { path: "/", params: [] };
+  }
+  if (ROUTE_SEGMENT_REGEX.test(urlPath)) {
+    urlPath = urlPath.replace(ROUTE_SEGMENT_REGEX, (match) => {
+      const paramName = match.replace(/[^a-zA-Z_\.]+/g, "");
+      params.push(paramName);
+      if (match.includes("...")) {
+        return "*";
+      } else {
+        return ":" + paramName;
+      }
+    });
+  }
+  return {
+    path: "/" + urlPath.split("/").map(
+      (segment) => segment.startsWith(":") || segment === "*" ? segment : segment.toLowerCase()
+    ).join("/"),
+    params
+  };
+}
+function isValidRoutePath(path) {
+  const isHiddenRoute = path.includes("/__");
+  const isTestFile = path.includes(".test") || path.includes(".spec");
+  return !isHiddenRoute && !isTestFile && Boolean(path);
+}
+function formDataToJSON(formData) {
+  let object = {};
+  const parseKey = (key) => {
+    const subKeyIdx = key.indexOf("[");
+    if (subKeyIdx !== -1) {
+      const keys = [key.substring(0, subKeyIdx)];
+      key = key.substring(subKeyIdx);
+      for (const match of key.matchAll(/\[(?<key>.*?)]/gm)) {
+        if (match.groups) {
+          keys.push(match.groups.key);
+        }
+      }
+      return keys;
+    } else {
+      return [key];
+    }
+  };
+  const assign = (keys, value, object2) => {
+    const key = keys.shift();
+    if (key === "" || key === void 0) {
+      return object2.push(value);
+    }
+    if (Reflect.has(object2, key)) {
+      if (keys.length === 0) {
+        if (!Array.isArray(object2[key])) {
+          object2[key] = [object2[key], value];
+          return;
+        }
+      }
+      return assign(keys, value, object2[key]);
+    }
+    if (keys.length >= 1) {
+      object2[key] = keys[0] === "" ? [] : {};
+      return assign(keys, value, object2[key]);
+    } else {
+      object2[key] = value;
+    }
+  };
+  const arrayify = (value) => {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+      return value;
+    }
+    const keys = Object.keys(value);
+    const allNumeric = keys.length > 0 && keys.every((key) => /^\d+$/.test(key));
+    if (allNumeric) {
+      const array = [];
+      for (const key of keys.sort((a, b) => Number(a) - Number(b))) {
+        array[Number(key)] = arrayify(value[key]);
+      }
+      return array;
+    }
+    for (const key of keys) {
+      value[key] = arrayify(value[key]);
+    }
+    return value;
+  };
+  for (const pair of formData.entries()) {
+    assign(parseKey(pair[0]), pair[1], object);
+  }
+  return arrayify(object);
+}
+function removeUndefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function buildUrl(base, diff, options) {
+  const next = new URL(base);
+  if (options?.clean) {
+    next.search = "";
+    next.hash = "";
+  }
+  if (diff?.pathname === null) {
+    next.pathname = "/";
+  } else if (diff?.pathname !== void 0) {
+    next.pathname = diff.pathname;
+  }
+  if (diff?.searchParams === null) {
+    next.search = "";
+  } else if (diff?.searchParams !== void 0) {
+    for (const [key, value] of Object.entries(diff.searchParams)) {
+      if (value === null || value === void 0) {
+        next.searchParams.delete(key);
+      } else {
+        next.searchParams.set(key, String(value));
+      }
+    }
+  }
+  if (diff?.hash === null) {
+    next.hash = "";
+  } else if (diff?.hash !== void 0) {
+    next.hash = diff.hash;
+  }
+  return next;
+}
+export {
+  assetHash,
+  buildUrl,
+  formDataToJSON,
+  isValidRoutePath,
+  parsePath,
+  randomHash,
+  removeUndefined
+};

package/package.json

@@ -1,63 +1,76 @@
 {
   "name": "@hyperspan/framework",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.1",
   "description": "Hyperspan Web Framework",
   "type": "module",
-  "main": "src/server.ts",
-  "types": "src/server.ts",
+  "main": "./dist/server.js",
+  "types": "./src/server.ts",
   "public": true,
+  "files": [
+    "dist",
+    "src",
+    "LICENSE.txt"
+  ],
   "publishConfig": {
     "access": "public",
-    "tag": "alpha"
+    "tag": "latest"
   },
   "exports": {
     ".": {
       "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "default": "./dist/index.js"
     },
     "./server": {
       "types": "./src/server.ts",
-      "default": "./src/server.ts"
+      "default": "./dist/server.js"
     },
     "./middleware": {
       "types": "./src/middleware.ts",
-      "default": "./src/middleware.ts"
+      "default": "./dist/middleware.js"
     },
     "./utils": {
       "types": "./src/utils.ts",
-      "default": "./src/utils.ts"
+      "default": "./dist/utils.js"
     },
     "./routes": {
       "types": "./src/register-routes.ts",
-      "default": "./src/register-routes.ts"
+      "default": "./dist/register-routes.js"
     },
     "./layout": {
       "types": "./src/layout.ts",
-      "default": "./src/layout.ts"
+      "default": "./dist/layout.js"
+    },
+    "./dev-bindings": {
+      "types": "./src/dev-bindings.ts",
+      "default": "./dist/dev-bindings.js"
     },
     "./client/css": {
       "types": "./src/client/css.ts",
-      "default": "./src/client/css.ts"
+      "default": "./dist/client/css.js"
     },
     "./client/js": {
       "types": "./src/client/js.ts",
-      "default": "./src/client/js.ts"
+      "default": "./dist/client/js.js"
     },
     "./client/manifest": {
       "types": "./src/client/manifest.ts",
-      "default": "./src/client/manifest.ts"
+      "default": "./dist/client/manifest.js"
     },
     "./actions": {
       "types": "./src/actions.ts",
-      "default": "./src/actions.ts"
+      "default": "./dist/actions.js"
+    },
+    "./html": {
+      "types": "./src/html.ts",
+      "default": "./dist/html.js"
     },
     "./ssr/install-server-dom-mock": {
       "types": "./src/ssr/install-server-dom-mock.ts",
-      "default": "./src/ssr/install-server-dom-mock.ts"
+      "default": "./dist/ssr/install-server-dom-mock.js"
     },
     "./ssr/mock-dom": {
       "types": "./src/ssr/mock-dom.ts",
-      "default": "./src/ssr/mock-dom.ts"
+      "default": "./dist/ssr/mock-dom.js"
     },
     "./client/_hs/hyperspan-streaming.client.ts": {
       "default": "./src/client/_hs/hyperspan-streaming.client.ts"
@@ -90,6 +103,8 @@
     "url": "https://github.com/vlucas/hyperspan/issues"
   },
   "scripts": {
+    "build": "node ../../scripts/build-node-packages.mjs framework",
+    "prepack": "npm run build",
     "test": "vitest run"
   },
   "devDependencies": {
@@ -97,10 +112,10 @@
     "@types/node": "^24.10.0",
     "prettier": "^3.5.2",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.10"
   },
   "dependencies": {
-    "@hyperspan/html": "^2.0.0-alpha.4",
+    "@hyperspan/html": "^2.0.1",
     "debug": "^4.4.3",
     "isbot": "^5.1.32",
     "zod": "^4.4.3"

package/src/actions.test.ts

@@ -1,7 +1,7 @@
 import { test, expect, describe } from 'vitest';
 import { createAction } from './actions';
 import { createRoute } from './server';
-import { html, render, placeholder, type HSHtml } from '@hyperspan/html';
+import { html, render, placeholder, type HSHtml } from './html';
 import { createContext } from './server';
 import * as z from 'zod';
 

package/src/actions.ts

@@ -1,4 +1,4 @@
-import { html } from '@hyperspan/html';
+import { html } from './html';
 import { createRoute, HTTPResponseException, returnHTMLResponse } from './server';
 import * as z from 'zod';
 import type { Hyperspan as HS } from './types';

package/src/adapter.test.ts

@@ -4,11 +4,7 @@ import { createConfig } from './server';
 
 const cloudflare: Adapter = {
   name: 'cloudflare',
-  createEntry() {
-    return {
-      fetch: async () => new Response('ok'),
-    };
-  },
+  renderServerEntry: (template) => template(),
 };
 
 describe('createConfig deployAdapter', () => {