@hyperspan/framework 2.0.0-alpha.7 → 2.0.1

package/dist/actions.js

@@ -0,0 +1,109 @@
+import { html } from "./html.js";
+import { createRoute, returnHTMLResponse } from "./server.js";
+import { assetHash, formDataToJSON } from "./utils.js";
+import { hyperspanActionsScriptTag } from "./layout.js";
+import { validateBody } from "./middleware.js";
+import debug from "debug";
+const log = debug("hyperspan:actions");
+function createAction(params) {
+  const { name, schema } = params;
+  const path = `/__actions/${assetHash(name)}`;
+  let _handler = null;
+  let _errorHandler = null;
+  function actionResponseOptions(status) {
+    return {
+      ...route._serverConfig?.responseOptions ?? {},
+      ...route._config?.responseOptions ?? {},
+      ...status !== void 0 ? { status } : {}
+    };
+  }
+  const route = createRoute({ path, name }).get((c) => api.render(c)).post(
+    async (c) => {
+      if (!_handler) {
+        throw new Error("Action POST handler not set! Every action must have a POST handler.");
+      }
+      const data = c.vars.body || formDataToJSON(await c.req.formData()) || {};
+      log("POST handler", { data });
+      const response = await _handler(c, { data });
+      log("POST handler response", { response });
+      if (response instanceof Response) {
+        if ([301, 302, 307, 308].includes(response.status)) {
+          response.headers.set("X-Redirect-Location", response.headers.get("Location") || "/");
+          response.headers.delete("Location");
+        }
+      }
+      return response;
+    },
+    { middleware: schema ? [validateBody(schema)] : [] }
+  ).errorHandler(async (c, err) => {
+    const data = c.vars.body || formDataToJSON(await c.req.formData()) || {};
+    const error = err._error || err;
+    c.res.status = err._error ? 400 : 500;
+    log("errorHandler", { data, error });
+    return await returnHTMLResponse(
+      c,
+      () => {
+        return _errorHandler ? _errorHandler(c, { data, error }) : api.render(c, { data, error });
+      },
+      actionResponseOptions(c.res.status ?? 400)
+    );
+  });
+  route._config.name = name;
+  const api = {
+    _kind: "hsAction",
+    _config: route._config,
+    get _serverConfig() {
+      return route._serverConfig;
+    },
+    set _serverConfig(config) {
+      route._serverConfig = config;
+    },
+    _path() {
+      return path;
+    },
+    _form: null,
+    /**
+     * Form to render
+     * This will be wrapped in a <hs-action> web component and submitted via fetch()
+     */
+    form(_formFn) {
+      api._form = _formFn;
+      return api;
+    },
+    /**
+     * Process form data
+     *
+     * Returns result from form processing if successful
+     * Re-renders form with data and error information otherwise
+     */
+    post(handler) {
+      _handler = handler;
+      return api;
+    },
+    /**
+     * Get form renderer method
+     */
+    render(c, props) {
+      const formContent = api._form ? api._form(c, props || {}) : null;
+      return formContent ? html`<hs-action url="${this._path()}">${formContent}</hs-action
+            >${hyperspanActionsScriptTag()}` : null;
+    },
+    errorHandler(handler) {
+      _errorHandler = handler;
+      return api;
+    },
+    use(middleware, opts) {
+      route.use(middleware, opts);
+      return api;
+    },
+    middleware(middleware, opts) {
+      route.middleware(middleware, opts);
+      return api;
+    },
+    fetch: route.fetch
+  };
+  return api;
+}
+export {
+  createAction
+};

package/dist/callsites.js

@@ -0,0 +1,18 @@
+function callsites() {
+  const _prepareStackTrace = Error.prepareStackTrace;
+  try {
+    let result = [];
+    Error.prepareStackTrace = (_, callSites) => {
+      const callSitesWithoutCurrent = callSites.slice(1);
+      result = callSitesWithoutCurrent;
+      return callSitesWithoutCurrent;
+    };
+    new Error().stack;
+    return result;
+  } finally {
+    Error.prepareStackTrace = _prepareStackTrace;
+  }
+}
+export {
+  callsites
+};

package/dist/client/css.js

@@ -0,0 +1,6 @@
+const CSS_PUBLIC_PATH = "/_hs/css";
+const CSS_ROUTE_MAP = /* @__PURE__ */ new Map();
+export {
+  CSS_PUBLIC_PATH,
+  CSS_ROUTE_MAP
+};

package/dist/client/js.js

@@ -0,0 +1,314 @@
+var __freeze = Object.freeze;
+var __defProp = Object.defineProperty;
+var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(raw || cooked.slice()) }));
+var _a, _b, _c, _d;
+import { readFileSync, existsSync } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { html } from "../html.js";
+import { assetHash as assetHashFn } from "../utils.js";
+import { getImportMap, registerImport, resolveImport } from "./manifest.js";
+import { registerImport as registerImport2, resolveImport as resolveImport2, getImportMap as getImportMap2 } from "./manifest.js";
+const JS_PUBLIC_PATH = "/_hs/js";
+const JS_ISLAND_PUBLIC_PATH = "/_hs/js/islands";
+const CLIENT_JS_REGISTRY = /* @__PURE__ */ Symbol.for("@hyperspan/client-js-entries");
+const CLIENT_JS_PATH_IDENTITIES = /* @__PURE__ */ Symbol.for("@hyperspan/client-js-path-identities");
+const PATH_ALIASES = /* @__PURE__ */ Symbol.for("@hyperspan/path-aliases");
+function getPathAliases() {
+  const globalAliases = globalThis;
+  if (!globalAliases[PATH_ALIASES]) {
+    globalAliases[PATH_ALIASES] = {};
+  }
+  return globalAliases[PATH_ALIASES];
+}
+function registerPathAliases(aliases) {
+  Object.assign(getPathAliases(), aliases);
+}
+function resolveWithAliases(specifier) {
+  const aliases = getPathAliases();
+  const keys = Object.keys(aliases).sort((a, b) => b.length - a.length);
+  for (const key of keys) {
+    if (specifier === key || specifier.startsWith(key)) {
+      const rest = specifier.slice(key.length).replace(/^\//, "");
+      return join(aliases[key], rest);
+    }
+  }
+  return void 0;
+}
+function getPathIdentityClientJS() {
+  const globalPathIdentities = globalThis;
+  if (!globalPathIdentities[CLIENT_JS_PATH_IDENTITIES]) {
+    globalPathIdentities[CLIENT_JS_PATH_IDENTITIES] = [];
+  }
+  return globalPathIdentities[CLIENT_JS_PATH_IDENTITIES];
+}
+function getClientJSRegistry() {
+  const globalRegistry = globalThis;
+  if (!globalRegistry[CLIENT_JS_REGISTRY]) {
+    globalRegistry[CLIENT_JS_REGISTRY] = /* @__PURE__ */ new Map();
+  }
+  return globalRegistry[CLIENT_JS_REGISTRY];
+}
+const JS_IMPORT_MAP = {
+  get size() {
+    return Object.keys(getImportMap()).length;
+  },
+  keys() {
+    return Object.keys(getImportMap()).values();
+  },
+  has(key) {
+    return resolveImport(key) !== void 0;
+  },
+  get(key) {
+    return resolveImport(key);
+  },
+  set(key, value) {
+    registerImport(key, value);
+    return this;
+  },
+  entries() {
+    return Object.entries(getImportMap()).values();
+  },
+  [Symbol.iterator]() {
+    return Object.entries(getImportMap())[Symbol.iterator]();
+  }
+};
+function stableClientSourceKey(absPath) {
+  const normalized = absPath.replace(/\\/g, "/");
+  const marker = "/node_modules/";
+  const idx = normalized.lastIndexOf(marker);
+  if (idx !== -1) {
+    return normalized.slice(idx + marker.length);
+  }
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
+    const rel = relative(process.cwd(), absPath).replace(/\\/g, "/");
+    if (rel && !rel.startsWith("..") && !isAbsolute(rel)) {
+      return rel;
+    }
+  }
+  return normalized;
+}
+function toFilePath(modulePath) {
+  return modulePath.startsWith("file://") ? fileURLToPath(modulePath) : modulePath;
+}
+function tryResolveToFile(specifier) {
+  try {
+    if (typeof import.meta.resolve !== "function") {
+      return void 0;
+    }
+    const resolved = import.meta.resolve(specifier);
+    if (typeof resolved === "string" && (resolved.startsWith("file://") || isAbsolute(resolved))) {
+      return toFilePath(resolved);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function clientPublicPath(esmName) {
+  return resolveImport(esmName) ?? `${JS_PUBLIC_PATH}/${esmName}.js`;
+}
+function clientIdentityKey(specifier) {
+  if (specifier.startsWith("file://") || isAbsolute(specifier)) {
+    return stableClientSourceKey(toFilePath(specifier));
+  }
+  return specifier;
+}
+function resolveClientAbsPath(specifier) {
+  if (specifier.startsWith("file://") || isAbsolute(specifier)) {
+    return toFilePath(specifier);
+  }
+  const aliased = resolveWithAliases(specifier);
+  if (aliased) {
+    return aliased;
+  }
+  const cwd = typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : "";
+  return tryResolveToFile(specifier) ?? (cwd ? join(cwd, specifier) : specifier);
+}
+function readClientSource(absPath) {
+  try {
+    if (existsSync(absPath)) {
+      return readFileSync(absPath, "utf-8");
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getClientJSEntries() {
+  return [...getClientJSRegistry().values()];
+}
+function getClientJSEntryByEsmName(esmName) {
+  return getClientJSRegistry().get(esmName);
+}
+function resetClientJSEntriesForTests() {
+  getClientJSRegistry().clear();
+  getPathIdentityClientJS().length = 0;
+  const aliases = getPathAliases();
+  for (const key of Object.keys(aliases)) {
+    delete aliases[key];
+  }
+}
+function registerClientJS(modulePathResolved, options = {}) {
+  const type = options.type ?? "module";
+  const specifier = modulePathResolved.replace(/\\/g, "/");
+  if (specifier.startsWith(".")) {
+    throw new Error(
+      `[Hyperspan] buildClientJS(${JSON.stringify(modulePathResolved)}) got a relative path, which has no stable identity across dev, build, and deploy. Use a tsconfig alias like '~/app/client/file.ts' \u2014 the build resolves it, and every runtime (including Workers, which cannot resolve paths) matches it in the asset manifest.`
+    );
+  }
+  const identityKey = clientIdentityKey(specifier);
+  const identityFromPath = identityKey !== specifier;
+  const hash = assetHashFn(identityKey);
+  const esmName = `client-${hash}`;
+  if (identityFromPath) {
+    getPathIdentityClientJS().push({ modulePath: modulePathResolved, identityKey });
+  }
+  let absPath;
+  let discovered;
+  function currentAbsPath() {
+    return absPath ??= resolveClientAbsPath(specifier);
+  }
+  function currentExports() {
+    if (!discovered) {
+      const source = readClientSource(currentAbsPath());
+      discovered = source ? discoverClientExports(source) : { exports: "* as _module", fnArgs: "_module" };
+    }
+    return discovered;
+  }
+  const entry = {
+    modulePath: modulePathResolved,
+    get absPath() {
+      return currentAbsPath();
+    },
+    identityKey,
+    identityFromPath,
+    assetHash: hash,
+    esmName,
+    get publicPath() {
+      return clientPublicPath(esmName);
+    },
+    get exports() {
+      return currentExports().exports;
+    },
+    get fnArgs() {
+      return currentExports().fnArgs;
+    },
+    type
+  };
+  getClientJSRegistry().set(esmName, entry);
+  registerImport(esmName, entry.publicPath);
+  return {
+    assetHash: hash,
+    esmName,
+    get publicPath() {
+      return clientPublicPath(esmName);
+    },
+    renderScriptTag: (loadScript) => {
+      if (type === "iife") {
+        return html(_a || (_a = __template(['<script src="', '"><\/script>'])), clientPublicPath(esmName));
+      }
+      const t = typeof loadScript;
+      const { exports, fnArgs } = currentExports();
+      if (t === "string") {
+        return html(_b || (_b = __template(['\n          <script type="module" data-source-id="', '">\n            import ', " from '", "';\n            (", ")(", ");\n          <\/script>\n        "])), hash, exports, esmName, html.raw(loadScript), fnArgs);
+      }
+      if (t === "function") {
+        return html(_c || (_c = __template(['\n          <script type="module" data-source-id="', '">\n            import ', " from '", "';\n            (", ")(", ");\n          <\/script>\n        "])), hash, exports, esmName, html.raw(functionToString(loadScript)), fnArgs);
+      }
+      return html(_d || (_d = __template(['\n        <script type="module" data-source-id="', `">
+          import '`, "';\n        <\/script>\n      "])), hash, esmName);
+    }
+  };
+}
+async function buildClientJS(modulePathResolved, options = {}) {
+  return registerClientJS(modulePathResolved, options);
+}
+const streamingClient = registerClientJS(
+  "@hyperspan/framework/client/_hs/hyperspan-streaming.client.ts",
+  { type: "iife" }
+);
+const actionsClient = registerClientJS(
+  "@hyperspan/framework/client/_hs/hyperspan-actions.client.ts"
+);
+function discoverClientExports(contents) {
+  const bundled = extractExports(contents);
+  if (bundled.exports !== "* as _module") {
+    return bundled;
+  }
+  const names = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const re of [
+    /export\s+(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g,
+    /export\s+const\s+([A-Za-z_$][\w$]*)/g,
+    /export\s+class\s+([A-Za-z_$][\w$]*)/g,
+    /export\s+let\s+([A-Za-z_$][\w$]*)/g
+  ]) {
+    let match;
+    while ((match = re.exec(contents)) !== null) {
+      if (!seen.has(match[1])) {
+        names.push(match[1]);
+        seen.add(match[1]);
+      }
+    }
+  }
+  const exportBlock = /export\s*\{([^}]+)\}/g;
+  let block;
+  while ((block = exportBlock.exec(contents)) !== null) {
+    for (const part of block[1].split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type ")) continue;
+      const asMatch = trimmed.match(/^(?:([\w$]+)\s+as\s+)?([\w$]+)$/);
+      const name = asMatch?.[2] ?? trimmed;
+      if (name && name !== "default" && !seen.has(name)) {
+        names.push(name);
+        seen.add(name);
+      }
+    }
+  }
+  if (names.length === 0) {
+    if (/export\s+default\b/.test(contents)) {
+      return { exports: "DefaultExport", fnArgs: "DefaultExport" };
+    }
+    return { exports: "* as _module", fnArgs: "_module" };
+  }
+  const exports = `{${names.join(", ")}}`;
+  return { exports, fnArgs: exports };
+}
+function extractExports(contents) {
+  const exportRegex = /export\{(.*)\}/g;
+  const exportLine = exportRegex.exec(contents);
+  let exports = "{}";
+  let fnArgs = "{}";
+  if (exportLine) {
+    const exportName = exportLine[1];
+    exports = "{" + exportName.split(",").map((name) => name.trim().split(" as ")).map(([name, alias]) => `${alias === "default" ? "default as " + name : alias}`).join(", ") + "}";
+  }
+  fnArgs = exports.replace(/(\w+)\s*as\s*(\w+)/g, "$1: $2").trim();
+  if (exports === "{}" && fnArgs === "{}") {
+    exports = "* as _module";
+    fnArgs = "_module";
+  }
+  return { exports, fnArgs };
+}
+function functionToString(fn) {
+  return fn.toString().trim();
+}
+export {
+  JS_IMPORT_MAP,
+  JS_ISLAND_PUBLIC_PATH,
+  JS_PUBLIC_PATH,
+  actionsClient,
+  buildClientJS,
+  discoverClientExports,
+  extractExports,
+  functionToString,
+  getClientJSEntries,
+  getClientJSEntryByEsmName,
+  getImportMap2 as getImportMap,
+  getPathIdentityClientJS,
+  registerImport2 as registerImport,
+  registerPathAliases,
+  resetClientJSEntriesForTests,
+  resolveImport2 as resolveImport,
+  stableClientSourceKey,
+  streamingClient
+};

package/dist/client/manifest.js

@@ -0,0 +1,55 @@
+const MANIFEST_KEY = /* @__PURE__ */ Symbol.for("@hyperspan/asset-manifest");
+function sharedManifest() {
+  const globalStore = globalThis;
+  if (!globalStore[MANIFEST_KEY]) {
+    globalStore[MANIFEST_KEY] = { imports: {}, css: {}, clients: {} };
+  }
+  return globalStore[MANIFEST_KEY];
+}
+function setAssetManifest(manifest) {
+  const store = sharedManifest();
+  store.imports = { ...manifest.imports ?? {} };
+  store.css = { ...manifest.css ?? {} };
+  store.clients = { ...manifest.clients ?? {} };
+}
+function getAssetManifest() {
+  return sharedManifest();
+}
+function resolveImport(name) {
+  return sharedManifest().imports[name];
+}
+function getRouteCss(path) {
+  return sharedManifest().css[path] ?? [];
+}
+function getImportMap() {
+  return { ...sharedManifest().imports };
+}
+function registerImport(name, publicPath) {
+  sharedManifest().imports[name] = publicPath;
+}
+function getClientJSFromManifest(moduleId, _exportNames = "default") {
+  const publicPath = sharedManifest().clients[moduleId];
+  if (!publicPath) {
+    throw new Error(
+      `[Hyperspan] Client module "${moduleId}" not found in asset manifest. Run hyperspan build or start dev server.`
+    );
+  }
+  const esmName = publicPath.split("/").pop()?.replace(".js", "") ?? moduleId;
+  return {
+    assetHash: moduleId,
+    esmName,
+    publicPath,
+    renderScriptTag: () => {
+      throw new Error("renderScriptTag requires html template - use layout helpers instead");
+    }
+  };
+}
+export {
+  getAssetManifest,
+  getClientJSFromManifest,
+  getImportMap,
+  getRouteCss,
+  registerImport,
+  resolveImport,
+  setAssetManifest
+};

package/dist/cookies.js

@@ -0,0 +1,142 @@
+const REGEXP_PAIR_SPLIT = /; */;
+const REGEXP_FIELD_CONTENT = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+class Cookies {
+  _req;
+  _responseHeaders;
+  _parsedCookies = {};
+  _encrypt;
+  _decrypt;
+  constructor(req, responseHeaders = void 0) {
+    this._req = req;
+    this._responseHeaders = responseHeaders;
+    this._parsedCookies = parse(req.headers.get("Cookie") || "");
+  }
+  get(name) {
+    const value = this._parsedCookies[name];
+    if (value && this._decrypt) {
+      return this._decrypt(value);
+    }
+    return value;
+  }
+  set(name, value, options) {
+    if (!this._responseHeaders) {
+      throw new Error("Set cookies in the response object. Cookies can only be read from the request object.");
+    }
+    if (this._encrypt) {
+      value = this._encrypt(value);
+    }
+    this._responseHeaders.append("Set-Cookie", serialize(name, value, options));
+  }
+  delete(name) {
+    this.set(name, "", { expires: /* @__PURE__ */ new Date(0) });
+  }
+  /**
+   * Set the encoder and decoder functions for the cookies and re-parse the cookie header
+   */
+  setEncryption(encrypt, decrypt) {
+    this._encrypt = encrypt;
+    this._decrypt = decrypt;
+    this._parsedCookies = parse(this._req.headers.get("Cookie") || "");
+  }
+}
+/*!
+ * cookie
+ * @source https://github.com/jkohrman/cookie-parse/blob/master/index.js
+ * Copyright(c) 2012-2014 Roman Shtylman
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * Copyright(c) 2016 Jeff Kohrman
+ * MIT Licensed
+ */
+function parse(str) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  const obj = {};
+  const pairs = str.split(REGEXP_PAIR_SPLIT);
+  for (let i = 0; i < pairs.length; i++) {
+    const pair = pairs[i];
+    let eq_idx = pair.indexOf("=");
+    let key;
+    let val;
+    if (eq_idx < 0) {
+      key = pair.trim();
+      val = "true";
+    } else {
+      key = pair.substring(0, eq_idx).trim();
+      val = pair.substring(eq_idx + 1, eq_idx + 1 + pair.length).trim();
+    }
+    ;
+    if ('"' == val[0]) {
+      val = val.slice(1, -1);
+    }
+    if (void 0 == obj[key]) {
+      obj[key] = tryDecode(val, decodeURIComponent);
+    }
+  }
+  return obj;
+}
+function serialize(name, val, options = {}) {
+  const opt = options || {};
+  if (!REGEXP_FIELD_CONTENT.test(name)) {
+    throw new TypeError("argument name is invalid");
+  }
+  let value = encodeURIComponent(val);
+  if (value && !REGEXP_FIELD_CONTENT.test(value)) {
+    throw new TypeError("argument val is invalid");
+  }
+  let str = name + "=" + value;
+  if (null != opt.maxAge) {
+    const maxAge = opt.maxAge - 0;
+    if (isNaN(maxAge)) throw new Error("maxAge should be a Number");
+    str += "; Max-Age=" + Math.floor(maxAge);
+  }
+  if (opt.domain) {
+    if (!REGEXP_FIELD_CONTENT.test(opt.domain)) {
+      throw new TypeError("option domain is invalid");
+    }
+    str += "; Domain=" + opt.domain;
+  }
+  if (opt.path) {
+    if (!REGEXP_FIELD_CONTENT.test(opt.path)) {
+      throw new TypeError("option path is invalid");
+    }
+    str += "; Path=" + opt.path;
+  }
+  if (opt.expires) {
+    if (typeof opt.expires.toUTCString !== "function") {
+      throw new TypeError("option expires must be a Date object");
+    }
+    str += "; Expires=" + opt.expires.toUTCString();
+  }
+  if (opt.httpOnly) {
+    str += "; HttpOnly";
+  }
+  if (opt.secure) {
+    str += "; Secure";
+  }
+  if (opt.sameSite) {
+    const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    switch (sameSite) {
+      case true:
+      case "strict":
+        str += "; SameSite=Strict";
+        break;
+      case "lax":
+        str += "; SameSite=Lax";
+        break;
+      default:
+        throw new TypeError("option sameSite is invalid");
+    }
+  }
+  return str;
+}
+function tryDecode(str, decode) {
+  try {
+    return decode(str);
+  } catch (e) {
+    return str;
+  }
+}
+export {
+  Cookies
+};

package/dist/dev-bindings.js

@@ -0,0 +1,15 @@
+let devBindings;
+function setDevBindings(env) {
+  devBindings = env;
+}
+function getDevBindings() {
+  return devBindings;
+}
+function clearDevBindingsForTests() {
+  devBindings = void 0;
+}
+export {
+  clearDevBindingsForTests,
+  getDevBindings,
+  setDevBindings
+};