abret 0.1.1

package/dist/html.js

@@ -0,0 +1,586 @@
+// @bun
+// src/store.ts
+import { AsyncLocalStorage } from "async_hooks";
+var contextStore = new AsyncLocalStorage;
+function createContext(name, ...args) {
+  const [defaultValue] = args;
+  const id = Symbol(name);
+  if (args.length > 0) {
+    const Provider = (props) => {
+      return props.children;
+    };
+    Provider._context = { id, defaultValue };
+    return {
+      id,
+      defaultValue,
+      Provider
+    };
+  }
+  return id;
+}
+function getContextId(context) {
+  if (typeof context === "symbol") {
+    return context;
+  }
+  return context.id;
+}
+function getDefaultValue(context) {
+  if (typeof context !== "symbol" && "defaultValue" in context) {
+    return context.defaultValue;
+  }
+  return;
+}
+var setContext = (context, value) => {
+  const store = contextStore.getStore();
+  if (!store) {
+    throw new Error("setContext must be called within a context scope. " + "Ensure you are inside a route handler or use runWithContext.");
+  }
+  store.set(getContextId(context), value);
+};
+function useContext(context, options) {
+  const store = contextStore.getStore();
+  const id = getContextId(context);
+  const value = store?.get(id);
+  if (value !== undefined) {
+    return value;
+  }
+  const defaultVal = getDefaultValue(context);
+  if (defaultVal !== undefined) {
+    return defaultVal;
+  }
+  if (options?.required) {
+    const name = typeof context === "symbol" ? context.description : context.id.description;
+    throw new Error(`Context "${name}" is required but not set`);
+  }
+  return;
+}
+var hasContext = (context) => {
+  const store = contextStore.getStore();
+  return store?.has(getContextId(context)) ?? false;
+};
+var clearContext = (context) => {
+  const store = contextStore.getStore();
+  if (store) {
+    store.delete(getContextId(context));
+  }
+};
+function runWithContext(fn) {
+  const currentStore = contextStore.getStore();
+  const newStore = currentStore ? new Map(currentStore) : new Map;
+  return contextStore.run(newStore, fn);
+}
+function runWithContextValue(context, value, fn) {
+  const currentStore = contextStore.getStore() || new Map;
+  const newStore = new Map(currentStore);
+  newStore.set(getContextId(context), value);
+  return contextStore.run(newStore, fn);
+}
+var getContextStore = () => contextStore;
+
+// src/jsx/index.ts
+class SafeString {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return this.value;
+  }
+}
+
+class AsyncBuffer extends ReadableStream {
+  promise;
+  constructor(promise) {
+    super({
+      async start(controller) {
+        try {
+          const result = await promise;
+          controller.enqueue(new TextEncoder().encode(result.toString()));
+          controller.close();
+        } catch (e) {
+          controller.error(e);
+        }
+      }
+    });
+    this.promise = promise;
+  }
+  then(onfulfilled, onrejected) {
+    return this.promise.then(onfulfilled, onrejected);
+  }
+  catch(onrejected) {
+    return this.promise.catch(onrejected);
+  }
+  finally(onfinally) {
+    return this.promise.finally(onfinally);
+  }
+}
+
+class VNode {
+  tag;
+  props;
+  children;
+  constructor(tag, props, children) {
+    this.tag = tag;
+    this.props = props;
+    this.children = children;
+  }
+}
+var Fragment = Symbol("Fragment");
+function jsx(tag, props) {
+  const { children, ...rest } = props || {};
+  return new VNode(tag, { ...rest, children }, children);
+}
+var jsxs = jsx;
+var jsxDEV = jsx;
+
+// src/html.ts
+class HTMLResponse extends Response {
+  _bodySource;
+  constructor(body, init) {
+    let normalizedBody = body;
+    if (body instanceof Promise) {
+      normalizedBody = new AsyncBuffer(body);
+    }
+    const headers = new Headers(init?.headers);
+    if (!headers.has("Content-Type")) {
+      headers.set("Content-Type", "text/html; charset=utf-8");
+    }
+    super(normalizedBody, { ...init, headers });
+    this._bodySource = body;
+  }
+  init(newInit) {
+    const currentHeaders = new Headers(this.headers);
+    if (newInit.headers) {
+      new Headers(newInit.headers).forEach((v, k) => {
+        currentHeaders.set(k, v);
+      });
+    }
+    return new HTMLResponse(this._bodySource, {
+      status: newInit.status ?? this.status,
+      statusText: newInit.statusText ?? this.statusText,
+      headers: currentHeaders
+    });
+  }
+  doctype(dt = true) {
+    let prefix = "";
+    if (dt === true)
+      prefix = "<!DOCTYPE html>";
+    else if (typeof dt === "string")
+      prefix = dt;
+    else
+      return this;
+    let newBodySource;
+    if (this._bodySource instanceof SafeString) {
+      newBodySource = raw(prefix + this._bodySource.toString());
+    } else if (this._bodySource instanceof Promise || this._bodySource instanceof AsyncBuffer) {
+      newBodySource = this._bodySource.then((content) => raw(prefix + content.toString()));
+    } else {
+      newBodySource = this._bodySource;
+    }
+    return new HTMLResponse(newBodySource, {
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers
+    });
+  }
+}
+var MODE_TEXT = 0;
+var MODE_TAGNAME = 1;
+var MODE_WHITESPACE = 2;
+var MODE_PROPNAME = 3;
+var MODE_PROPVAL = 4;
+var MODE_PROPVAL_QUOTE = 5;
+var MODE_CLOSE_TAG = 6;
+function html(bodyOrStrings, ...args) {
+  if (Array.isArray(bodyOrStrings) && bodyOrStrings.raw) {
+    const vnode = parse(bodyOrStrings, args);
+    const rendered2 = render(vnode);
+    if (rendered2 instanceof Promise) {
+      return new HTMLResponse(rendered2.then((s) => raw(processMetadata(s.toString()))));
+    }
+    return new HTMLResponse(raw(processMetadata(rendered2.toString())));
+  }
+  const rendered = render(bodyOrStrings);
+  if (rendered instanceof Promise) {
+    return new HTMLResponse(rendered.then((s) => raw(processMetadata(s.toString()))));
+  }
+  return new HTMLResponse(raw(processMetadata(rendered.toString())));
+}
+function parse(statics, fields) {
+  let mode = MODE_TEXT;
+  let buffer = "";
+  let quote = "";
+  let char = "";
+  let propName;
+  const root = { children: [] };
+  let active = root;
+  const stack = [active];
+  for (let i = 0;i < statics.length; i++) {
+    if (i) {
+      if (mode === MODE_TEXT) {
+        commit();
+        active.children.push(fields[i - 1]);
+      } else if (mode === MODE_TAGNAME) {
+        commit();
+        const tag = fields[i - 1];
+        active = openTag(stack, active, tag);
+        mode = MODE_WHITESPACE;
+      } else if (mode === MODE_WHITESPACE) {
+        const val = fields[i - 1];
+        if (buffer === "...") {
+          Object.assign(active.props, val);
+          buffer = "";
+        } else {}
+      } else if (mode === MODE_PROPNAME) {
+        propName = fields[i - 1];
+        mode = MODE_PROPVAL;
+      } else if (mode === MODE_PROPVAL) {
+        active.props[propName] = fields[i - 1];
+        mode = MODE_WHITESPACE;
+      } else if (mode === MODE_PROPVAL_QUOTE) {
+        buffer += fields[i - 1];
+      }
+    }
+    const chunk = statics[i];
+    if (!chunk)
+      continue;
+    for (let j = 0;j < chunk.length; j++) {
+      char = chunk[j];
+      if (char === undefined)
+        continue;
+      if (mode === MODE_TEXT) {
+        if (char === "<") {
+          commit();
+          mode = MODE_TAGNAME;
+        } else {
+          buffer += char;
+        }
+      } else if (mode === MODE_TAGNAME) {
+        if (char === "/" && !buffer) {
+          mode = MODE_CLOSE_TAG;
+        } else if (char === ">" || char === "/" || /\s/.test(char)) {
+          if (buffer) {
+            active = openTag(stack, active, buffer);
+          }
+          if (char === ">")
+            mode = MODE_TEXT;
+          else if (char === "/") {
+            if (stack.length > 1) {
+              closeTag(stack);
+              active = stack[stack.length - 1];
+            }
+          } else
+            mode = MODE_WHITESPACE;
+          buffer = "";
+        } else {
+          buffer += char;
+        }
+      } else if (mode === MODE_CLOSE_TAG) {
+        if (char === ">") {
+          closeTag(stack);
+          active = stack[stack.length - 1];
+          mode = MODE_TEXT;
+          buffer = "";
+        }
+      } else if (mode === MODE_WHITESPACE) {
+        if (char === "/") {
+          closeTag(stack);
+          active = stack[stack.length - 1];
+        } else if (char === ">") {
+          mode = MODE_TEXT;
+        } else if (!/\s/.test(char)) {
+          mode = MODE_PROPNAME;
+          buffer = char;
+        }
+      } else if (mode === MODE_PROPNAME) {
+        if (char === "=") {
+          propName = buffer;
+          buffer = "";
+          mode = MODE_PROPVAL;
+        } else if (char === ">") {
+          active.props[buffer] = true;
+          mode = MODE_TEXT;
+          buffer = "";
+        } else if (/\s/.test(char)) {
+          active.props[buffer] = true;
+          mode = MODE_WHITESPACE;
+          buffer = "";
+        } else {
+          buffer += char;
+        }
+      } else if (mode === MODE_PROPVAL) {
+        if (char === '"' || char === "'") {
+          quote = char;
+          mode = MODE_PROPVAL_QUOTE;
+        } else if (char === ">") {
+          active.props[propName] = buffer;
+          mode = MODE_TEXT;
+          buffer = "";
+        } else if (/\s/.test(char)) {
+          active.props[propName] = buffer;
+          mode = MODE_WHITESPACE;
+          buffer = "";
+        } else {
+          buffer += char;
+        }
+      } else if (mode === MODE_PROPVAL_QUOTE) {
+        if (char === quote) {
+          active.props[propName] = buffer;
+          mode = MODE_WHITESPACE;
+          buffer = "";
+        } else {
+          buffer += char;
+        }
+      }
+    }
+  }
+  if (mode === MODE_TEXT)
+    commit();
+  function commit() {
+    if (buffer) {
+      if (mode === MODE_TEXT) {
+        active.children.push(raw(buffer));
+      }
+      buffer = "";
+    }
+  }
+  function openTag(stack2, current, tag) {
+    const newNode = { tag, props: {}, children: [] };
+    current.children.push(newNode);
+    stack2.push(newNode);
+    return newNode;
+  }
+  function closeTag(stack2) {
+    if (stack2.length > 1)
+      stack2.pop();
+  }
+  if (root.children.length === 1)
+    return toVNode(root.children[0]);
+  return root.children.map(toVNode);
+}
+function toVNode(node) {
+  if (node === null || node === undefined)
+    return node;
+  if (node instanceof SafeString || typeof node !== "object")
+    return node;
+  if (node instanceof Promise || node instanceof AsyncBuffer)
+    return node;
+  if (node instanceof VNode)
+    return node;
+  if (Array.isArray(node))
+    return node.map(toVNode);
+  if (!node.children || !Array.isArray(node.children)) {
+    return node;
+  }
+  const children = node.children.map(toVNode);
+  const props = { ...node.props, children };
+  return new VNode(node.tag, props, children);
+}
+function render(node) {
+  if (node instanceof HTMLResponse) {
+    return render(node._bodySource);
+  }
+  if (node === null || node === undefined || typeof node === "boolean") {
+    return raw("");
+  }
+  if (node instanceof SafeString)
+    return node;
+  if (typeof node === "number" || typeof node === "bigint")
+    return raw(String(node));
+  if (node instanceof Promise || node instanceof AsyncBuffer) {
+    return node.then(render);
+  }
+  if (Array.isArray(node)) {
+    const results = node.map(render);
+    if (results.some((r) => r instanceof Promise)) {
+      return Promise.all(results).then((parts) => raw(parts.map((p) => p.toString()).join("")));
+    }
+    return raw(results.map((r) => r.toString()).join(""));
+  }
+  if (node instanceof VNode) {
+    if (typeof node.tag === "function") {
+      const providerCtx = node.tag._context;
+      if (providerCtx) {
+        const value = node.props.value;
+        const contextStore2 = getContextStore();
+        const currentStore = contextStore2.getStore() || new Map;
+        const newStore = new Map(currentStore);
+        newStore.set(providerCtx.id, value);
+        return contextStore2.run(newStore, () => {
+          return render(node.props.children);
+        });
+      }
+      let result;
+      try {
+        result = node.tag(node.props);
+      } catch (e) {
+        console.error("Error rendering component", e);
+        return raw("");
+      }
+      return render(result);
+    }
+    if (node.tag === Fragment) {
+      return render(node.children);
+    }
+    if (typeof node.tag === "string") {
+      const tag = node.tag;
+      const { children, dangerouslySetInnerHTML, ...rest } = node.props;
+      const attrs = Object.entries(rest).map(([key, value]) => {
+        if (value === null || value === undefined || value === false)
+          return "";
+        if (key === "className")
+          key = "class";
+        if (key === "style")
+          value = renderStyle(value);
+        if (value === true)
+          return ` ${key}`;
+        return ` ${key}="${escapeHtml(String(value))}"`;
+      }).join("");
+      if (VOID_TAGS.has(tag)) {
+        return raw(`<${tag}${attrs} />`);
+      }
+      if (dangerouslySetInnerHTML?.__html) {
+        return raw(`<${tag}${attrs}>${dangerouslySetInnerHTML.__html}</${tag}>`);
+      }
+      const childrenList = Array.isArray(children) ? children : [children];
+      const renderedChildrenResult = render(childrenList);
+      if (renderedChildrenResult instanceof Promise) {
+        return renderedChildrenResult.then((c) => raw(`<${tag}${attrs}>${c.toString()}</${tag}>`));
+      }
+      return raw(`<${tag}${attrs}>${renderedChildrenResult.toString()}</${tag}>`);
+    }
+  }
+  return raw(escapeHtml(String(node)));
+}
+var VOID_TAGS = new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var ESCAPE_REGEX = /[&<>"']/g;
+var ESCAPE_LOOKUP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(str) {
+  if (typeof str !== "string")
+    return str;
+  return str.replace(ESCAPE_REGEX, (match) => ESCAPE_LOOKUP[match]);
+}
+function kebabCase(str) {
+  return str.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function renderStyle(style) {
+  if (typeof style === "string")
+    return style;
+  return Object.entries(style).map(([k, v]) => `${kebabCase(k)}:${v}`).join(";");
+}
+function processMetadata(html2) {
+  const metaTags = [];
+  const linkTags = [];
+  let titleTag = null;
+  const extractedHtml = html2.replace(/<title(?:\s[^>]*)?>([\s\S]*?)<\/title>|<meta(?:\s[^>]*)?\/?>|<link(?:\s[^>]*)?\/?>/gi, (match) => {
+    if (match.toLowerCase().startsWith("<title")) {
+      titleTag = match;
+      return "";
+    }
+    if (match.toLowerCase().startsWith("<meta")) {
+      const name = match.match(/name=["']([^"']+)["']/i);
+      const property = match.match(/property=["']([^"']+)["']/i);
+      const charset = match.match(/charset=["']([^"']+)["']/i);
+      const httpEquiv = match.match(/http-equiv=["']([^"']+)["']/i);
+      let key;
+      if (name?.[1])
+        key = `name:${name[1]}`;
+      else if (property?.[1])
+        key = `property:${property[1]}`;
+      else if (charset?.[1])
+        key = "charset";
+      else if (httpEquiv?.[1])
+        key = `http-equiv:${httpEquiv[1]}`;
+      metaTags.push({ tag: "meta", content: match, key });
+      return "";
+    }
+    if (match.toLowerCase().startsWith("<link")) {
+      const rel = match.match(/rel=["']([^"']+)["']/i);
+      const key = rel?.[1]?.toLowerCase() === "canonical" ? "canonical" : undefined;
+      linkTags.push({ tag: "link", content: match, key });
+      return "";
+    }
+    return match;
+  });
+  const headContent = [];
+  const metaMap = new Map;
+  metaTags.forEach((m) => {
+    if (m.key)
+      metaMap.set(m.key, m.content);
+  });
+  if (metaMap.has("charset")) {
+    const charsetTag = metaMap.get("charset");
+    if (charsetTag)
+      headContent.push(charsetTag);
+    metaMap.delete("charset");
+  }
+  if (titleTag)
+    headContent.push(titleTag);
+  if (metaMap.has("name:viewport")) {
+    const viewportTag = metaMap.get("name:viewport");
+    if (viewportTag)
+      headContent.push(viewportTag);
+    metaMap.delete("name:viewport");
+  }
+  metaMap.forEach((v) => {
+    headContent.push(v);
+  });
+  metaTags.filter((m) => !m.key).forEach((m) => {
+    headContent.push(m.content);
+  });
+  const linkMap = new Map;
+  linkTags.forEach((l) => {
+    if (l.key)
+      linkMap.set(l.key, l.content);
+    else
+      headContent.push(l.content);
+  });
+  linkMap.forEach((v) => {
+    headContent.push(v);
+  });
+  const headString = headContent.join("");
+  if (extractedHtml.includes("<head>")) {
+    return extractedHtml.replace("<head>", `<head>${headString}`);
+  }
+  if (extractedHtml.match(/<html/i)) {
+    return extractedHtml.replace(/(<html[^>]*>)/i, `$1<head>${headString}</head>`);
+  }
+  if (headContent.length > 0) {
+    return `<head>${headString}</head>${extractedHtml}`;
+  }
+  return extractedHtml;
+}
+function raw(str) {
+  return new SafeString(str);
+}
+export {
+  render,
+  raw,
+  html,
+  VNode,
+  SafeString,
+  HTMLResponse,
+  Fragment,
+  AsyncBuffer
+};

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+export { createContext, runWithContext, runWithContextValue, useContext, } from "./store";
+/**
+ * Next function type for middleware chain
+ */
+export type NextFunction = () => Response | Promise<Response>;
+/**
+ * Middleware function type
+ * @param req - The incoming request
+ * @param server - The Bun server instance
+ * @param next - Function to call the next middleware/handler
+ * @returns Response or Promise<Response>
+ */
+export type Middleware<P extends string = string, S = undefined> = (req: Bun.BunRequest<P>, server: Bun.Server<S>, next: NextFunction) => Response | Promise<Response>;
+/**
+ * Route handler type - can be a Response, handler function, or method handlers
+ */
+export type RouteValue<P extends string = string, S = undefined> = Bun.Serve.BaseRouteValue | Bun.Serve.Handler<Bun.BunRequest<P>, Bun.Server<S>, Response> | Partial<Record<Bun.Serve.HTTPMethod, Response | Bun.Serve.Handler<Bun.BunRequest<P>, Bun.Server<S>, Response>>>;
+/**
+ * Creates a route with optional middleware support.
+ * Registers the path exactly as defined.
+ *
+ * @example
+ * ```ts
+ * const home = createRoute("/", () => new Response("Hello World"));
+ *
+ * const api = createRoute(
+ *   "/api/users",
+ *   {
+ *     GET: () => Response.json({ users: [] }),
+ *     POST: async (req) => Response.json({ created: true }),
+ *   },
+ *   authMiddleware,
+ * );
+ * ```
+ */
+export declare const createRoute: <P extends string, S = undefined>(path: P, value: RouteValue<P, S>, ...middlewares: Middleware<P, S>[]) => Record<P, RouteValue<P, S>>;
+/**
+ * Helper to create a middleware function with proper typing
+ *
+ * @example
+ * ```ts
+ * const authMiddleware = createMiddleware(async (req, server, next) => {
+ *   const token = req.headers.get("Authorization");
+ *   if (!token) {
+ *     return new Response("Unauthorized", { status: 401 });
+ *   }
+ *   return next();
+ * });
+ * ```
+ */
+export declare const createMiddleware: <P extends string = string, S = undefined>(fn: Middleware<P, S>) => Middleware<P, S>;
+/**
+ * Compose multiple middlewares into a single middleware
+ *
+ * @example
+ * ```ts
+ * const combinedMiddleware = composeMiddlewares(
+ *   loggingMiddleware,
+ *   authMiddleware,
+ *   rateLimitMiddleware
+ * );
+ * ```
+ */
+export declare const composeMiddlewares: <P extends string = string, S = undefined>(...middlewares: Middleware<P, S>[]) => Middleware<P, S>;
+/**
+ * Type for a single route object returned by createRoute
+ * Uses Record<string, any> to allow typed route objects to be merged
+ */
+export type RouteObject = Record<string, any>;
+/**
+ * Merges multiple route objects into a single routes object.
+ * Preserves type information from each route for proper typing.
+ *
+ * @example
+ * ```ts
+ * const index = createRoute("/", () => new Response("Home"));
+ * const api = createRoute("/api", { GET: () => Response.json({ ok: true }) });
+ *
+ * Bun.serve({
+ *   routes: mergeRoutes(index, api),
+ * });
+ * ```
+ */
+export declare const mergeRoutes: <T extends RouteObject[]>(...routes: T) => UnionToIntersection<T[number]>;
+/**
+ * Helper type to convert union to intersection
+ * @internal
+ */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Creates a route group factory with a common prefix and optional shared middlewares.
+ *
+ * @example
+ * ```ts
+ * const api = createRouteGroup("/api", [authMiddleware]);
+ *
+ * const routes = mergeRoutes(
+ *   api("/users", { GET: () => Response.json([]) }),
+ *   api("/users/:id", (req) => Response.json({ id: req.params.id })),
+ * );
+ * ```
+ */
+export declare const createRouteGroup: <Prefix extends string, S = undefined>(prefix: Prefix, middlewares?: Middleware<string, S>[]) => <P extends string>(path: P, value: RouteValue<`${Prefix}${P}`, S>) => Record<`${Prefix}${P}`, RouteValue<`${Prefix}${P}`, S>>;