abret 0.1.1

package/dist/index.js

@@ -0,0 +1,161 @@
+// @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/index.ts
+var wrapWithMiddleware = (handler, middlewares) => {
+  return (req, server) => {
+    return runWithContext(() => {
+      if (middlewares.length === 0) {
+        return handler(req, server);
+      }
+      let index = 0;
+      const next = () => {
+        if (index < middlewares.length) {
+          const middleware = middlewares[index++];
+          if (middleware)
+            return middleware(req, server, next);
+        }
+        return handler(req, server);
+      };
+      return next();
+    });
+  };
+};
+var wrapRouteValue = (value, middlewares) => {
+  if (middlewares.length === 0) {
+    return value;
+  }
+  if (value instanceof Response) {
+    return wrapWithMiddleware(() => value, middlewares);
+  }
+  if (typeof value === "function") {
+    return wrapWithMiddleware(value, middlewares);
+  }
+  if (typeof value === "object" && value !== null) {
+    const wrappedMethods = {};
+    for (const [method, methodHandler] of Object.entries(value)) {
+      if (methodHandler instanceof Response) {
+        wrappedMethods[method] = wrapWithMiddleware(() => methodHandler, middlewares);
+      } else if (typeof methodHandler === "function") {
+        wrappedMethods[method] = wrapWithMiddleware(methodHandler, middlewares);
+      }
+    }
+    return wrappedMethods;
+  }
+  return value;
+};
+var createRoute = (path, value, ...middlewares) => {
+  const wrappedValue = wrapRouteValue(value, middlewares);
+  return { [path]: wrappedValue };
+};
+var createMiddleware = (fn) => fn;
+var composeMiddlewares = (...middlewares) => {
+  return (req, server, finalNext) => {
+    let index = 0;
+    const next = () => {
+      if (index < middlewares.length) {
+        const middleware = middlewares[index++];
+        if (middleware)
+          return middleware(req, server, next);
+      }
+      return finalNext();
+    };
+    return next();
+  };
+};
+var mergeRoutes = (...routes) => {
+  return Object.assign({}, ...routes);
+};
+var createRouteGroup = (prefix, middlewares = []) => {
+  return (path, value) => {
+    const fullPath = `${prefix}${path}`;
+    return createRoute(fullPath, value, ...middlewares);
+  };
+};
+export {
+  useContext,
+  runWithContextValue,
+  runWithContext,
+  mergeRoutes,
+  createRouteGroup,
+  createRoute,
+  createMiddleware,
+  createContext,
+  composeMiddlewares
+};

package/dist/jsx/index.d.ts

@@ -0,0 +1,38 @@
+export declare class SafeString {
+    value: string;
+    constructor(value: string);
+    toString(): string;
+}
+export declare class AsyncBuffer extends ReadableStream<Uint8Array> {
+    private promise;
+    constructor(promise: Promise<SafeString>);
+    then<TResult1 = SafeString, TResult2 = never>(onfulfilled?: ((value: SafeString) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<SafeString | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<SafeString>;
+}
+export declare class VNode {
+    tag: string | ((props: any) => any) | typeof Fragment;
+    props: Record<string, any>;
+    children: any;
+    constructor(tag: string | ((props: any) => any) | typeof Fragment, props: Record<string, any>, children: any);
+}
+export type JSXNode = string | number | boolean | bigint | null | undefined | JSXNode[] | Promise<JSXNode> | SafeString | AsyncBuffer | VNode;
+export declare const Fragment: unique symbol;
+export declare function jsx(tag: string | ((props: any) => any) | typeof Fragment, props: Record<string, any>): VNode;
+export declare const jsxs: typeof jsx;
+export declare const jsxDEV: typeof jsx;
+export declare namespace JSX {
+    type Element = VNode | SafeString | AsyncBuffer | Promise<SafeString>;
+    type ElementType = string | ((props: any) => JSXNode);
+    interface IntrinsicElements {
+        [elemName: string]: {
+            dangerouslySetInnerHTML?: {
+                __html: string;
+            };
+            [key: string]: any;
+        };
+    }
+    interface ElementChildrenAttribute {
+        children: unknown;
+    }
+}

package/dist/jsx/jsx-dev-runtime.d.ts

@@ -0,0 +1 @@
+export * from ".";

package/dist/jsx/jsx-dev-runtime.js

@@ -0,0 +1,65 @@
+// @bun
+// 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;
+export {
+  jsxs,
+  jsxDEV,
+  jsx,
+  VNode,
+  SafeString,
+  Fragment,
+  AsyncBuffer
+};

package/dist/jsx/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export * from ".";

package/dist/jsx/jsx-runtime.js

@@ -0,0 +1,65 @@
+// @bun
+// 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;
+export {
+  jsxs,
+  jsxDEV,
+  jsx,
+  VNode,
+  SafeString,
+  Fragment,
+  AsyncBuffer
+};

package/dist/middleware/static/index.d.ts

@@ -0,0 +1,31 @@
+import type { Middleware } from "../..";
+export type ServeStaticOptions = {
+    /**
+     * Root directory to serve files from.
+     * @default "./"
+     */
+    root?: string;
+    /**
+     * Path to specific file to serve.
+     * If set, this file will be served for all requests.
+     */
+    path?: string;
+    /**
+     * Rewrite the request path before file resolution.
+     */
+    rewriteRequestPath?: (path: string) => string;
+    /**
+     * Custom mapping of mime types.
+     * Extension (without dot) -> Mime Type
+     */
+    mimes?: Record<string, string>;
+    /**
+     * Callback when file is not found.
+     */
+    onNotFound?: (path: string, req: Request) => void;
+};
+/**
+ * Middleware to serve static files using Bun.file
+ * behaves like hono serveStatic
+ */
+export declare const serveStatic: (options?: ServeStaticOptions) => Middleware;

package/dist/middleware/static/index.js

@@ -0,0 +1,40 @@
+// @bun
+// src/middleware/static/index.ts
+import path from "path";
+var serveStatic = (options = {}) => {
+  return async (req, _server, next) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      return next();
+    }
+    const url = new URL(req.url);
+    let filename = options.path ?? url.pathname;
+    if (options.rewriteRequestPath) {
+      filename = options.rewriteRequestPath(filename);
+    }
+    const root = options.root ?? "./";
+    const validFilename = filename.startsWith("/") ? filename.slice(1) : filename;
+    const filePath = path.resolve(root, validFilename);
+    const resolvedRoot = path.resolve(root);
+    if (!filePath.startsWith(resolvedRoot)) {
+      return next();
+    }
+    const file = Bun.file(filePath);
+    if (await file.exists()) {
+      const response = new Response(file);
+      if (options.mimes) {
+        const ext = path.extname(filePath).slice(1);
+        if (options.mimes[ext]) {
+          response.headers.set("Content-Type", options.mimes[ext]);
+        }
+      }
+      return response;
+    }
+    if (options.onNotFound) {
+      options.onNotFound(filePath, req);
+    }
+    return next();
+  };
+};
+export {
+  serveStatic
+};

package/dist/store.d.ts

@@ -0,0 +1,148 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+/**
+ * Context type for type-safe context access
+ */
+export type Context<T> = symbol & {
+    __type: T;
+};
+/**
+ * JSX Context interface with Provider component and default value
+ */
+export interface ContextWithProvider<T> {
+    /**
+     * Unique ID for this context
+     */
+    id: Context<T>;
+    /**
+     * Default value when context is not set
+     */
+    defaultValue: T;
+    /**
+     * Provider component for JSX usage
+     */
+    Provider: (props: {
+        value: T;
+        children: unknown;
+    }) => any;
+}
+/**
+ * Creates a typed context for storing/retrieving values.
+ * Works with both request handlers and JSX components.
+ *
+ * @example
+ * ```ts
+ * import { createContext, useContext, setContext } from "abret/store";
+ *
+ * // Define context (without default - returns undefined if not set)
+ * const UserContext = createContext<{ id: string; name: string }>("user");
+ *
+ * // Define context (with default value)
+ * const ThemeContext = createContext("theme", "light");
+ *
+ * // In middleware - set context (no req parameter needed!)
+ * const authMiddleware = createMiddleware(() => async (req, _server, next) => {
+ *   const user = await validateToken(req.headers.get("Authorization"));
+ *   setContext(UserContext, user);
+ *   return next();
+ * });
+ *
+ * // In handler - use context (no req parameter needed!)
+ * const handler = () => {
+ *   const user = useContext(UserContext);
+ *   return Response.json({ user });
+ * };
+ *
+ * // In JSX component
+ * function UserProfile() {
+ *   const user = useContext(UserContext);
+ *   return <div>{user?.name}</div>;
+ * }
+ * ```
+ */
+export declare function createContext<T>(name: string): Context<T>;
+export declare function createContext<T>(name: string, defaultValue: T): ContextWithProvider<T>;
+/**
+ * Sets a value in the current context scope.
+ * Must be called within a context scope (e.g., inside route handler or runWithContext).
+ *
+ * @example
+ * ```ts
+ * setContext(UserContext, { id: "123", name: "John" });
+ * ```
+ */
+export declare const setContext: <T>(context: Context<T> | ContextWithProvider<T>, value: T) => void;
+/**
+ * Options for useContext
+ */
+export interface UseContextOptions {
+    /**
+     * If true, throws an error when context is not set.
+     * @default false
+     */
+    required?: boolean;
+}
+/**
+ * Gets a value from the current context scope.
+ * Returns undefined if not set, or the default value if context was created with one.
+ *
+ * @example
+ * ```ts
+ * // Optional context
+ * const user = useContext(UserContext);
+ *
+ * // Required context (throws if not set)
+ * const user = useContext(UserContext, { required: true });
+ *
+ * // Context with default value
+ * const ThemeContext = createContext("theme", "light");
+ * const theme = useContext(ThemeContext); // returns "light" if not set
+ * ```
+ */
+export declare function useContext<T>(context: Context<T>): T | undefined;
+export declare function useContext<T>(context: ContextWithProvider<T>): T;
+export declare function useContext<T>(context: Context<T>, options: {
+    required: true;
+}): T;
+/**
+ * Checks if a context has been set in the current scope.
+ */
+export declare const hasContext: <T>(context: Context<T> | ContextWithProvider<T>) => boolean;
+/**
+ * Clears a specific context in the current scope.
+ */
+export declare const clearContext: <T>(context: Context<T> | ContextWithProvider<T>) => void;
+/**
+ * Runs a function within a new context scope.
+ * All setContext/useContext calls within the function will use this scope.
+ *
+ * This is used internally by the router to wrap each request,
+ * but can also be used manually for testing or custom scenarios.
+ *
+ * @example
+ * ```ts
+ * const result = await runWithContext(async () => {
+ *   setContext(UserContext, { id: "123", name: "John" });
+ *   return handleRequest();
+ * });
+ * ```
+ */
+export declare function runWithContext<R>(fn: () => R): R;
+/**
+ * Runs a function with a specific context value set.
+ * Useful for Provider components in JSX.
+ *
+ * @example
+ * ```ts
+ * const result = runWithContextValue(ThemeContext, "dark", () => {
+ *   return useContext(ThemeContext); // returns "dark"
+ * });
+ * ```
+ */
+export declare function runWithContextValue<T, R>(context: Context<T> | ContextWithProvider<T>, value: T, fn: () => R): R;
+/**
+ * Gets the raw AsyncLocalStorage instance.
+ * Useful for advanced use cases or framework integration.
+ *
+ * @internal
+ */
+export declare const getContextStore: () => AsyncLocalStorage<Map<symbol, unknown>>;

package/dist/store.js

@@ -0,0 +1,88 @@
+// @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;
+export {
+  useContext,
+  setContext,
+  runWithContextValue,
+  runWithContext,
+  hasContext,
+  getContextStore,
+  createContext,
+  clearContext
+};