attay 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Harshdeep Singh Hura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,190 @@
+# Attay (ਅਤੈ / and)
+
+Attay is intentionally personal.
+
+It exists because I got tired of bending code around other people’s opinions. Instead, Attay codifies a workflow that already works well and makes it reusable.
+
+Attay is meant to sit **next to your code**, not above it. It’s _`and`_, not `instead of`.
+
+## What Attay Is
+
+Attay is a small, opinionated toolkit built around:
+
+- **Bun** on the server
+- **Preact** on the client
+- Filesystem-driven routing
+- Minimal configuration
+- Explicit control over runtime behavior
+
+It favors:
+
+- Composition over magic
+- Plain platform primitives over wrappers
+- Code you can read in one sitting
+
+## What Attay Is Not
+
+- It is not a "universal" framework
+- It is not designed to please every use case
+- It does not attempt to abstract away the platform
+- It does not follow whatever is popular this year
+
+---
+
+## Server
+
+The server side of Attay is a **route calculator** for Bun.
+
+You define routes using a filesystem structure. Attay converts that structure into a `routes` object that Bun understands. You still own:
+
+- `Bun.serve`
+- request handling
+- server lifecycle
+
+Attay simply removes the boring glue.
+
+```js
+import attayRoutes from "attay/server";
+
+const autoRoutes = await attayRoutes({ dir: "./api", prefix: "/pre" });
+const server = Bun.serve({
+  routes: {
+    ...autoRoutes,
+  },
+});
+```
+
+You can mix calculated routes and manual routes freely.
+
+### Route Prefix
+
+Attay supports an optional `prefix` option that is prepended to **every calculated API route**.
+
+This is useful when you want to mount your API under a specific base path without changing your filesystem structure.
+
+```js
+await attayRoutes({ dir: "./api" });
+```
+
+```
+api/GET.ts        -> /
+api/users/GET.ts -> /users
+```
+
+```js
+await attayRoutes({ dir: "./api", prefix: "/pre" });
+```
+
+```
+api/GET.ts        -> /pre/
+api/users/GET.ts -> /pre/users
+```
+
+The prefix:
+
+- Defaults to empty (`""`)
+- Is normalized automatically (leading slash added, trailing slash removed)
+- Applies only to API routes (client routes are not prefixed)
+
+### Middleware
+
+Attay provides a small middleware helper for the server: `withMiddleware`.
+
+Middleware exists to share logic across routes without inventing a new request lifecycle. It is deliberately minimal.
+
+```js
+import { withMiddleware } from "attay/server";
+import logMethodMiddleware from "@/middleware/logMethodMiddleware";
+
+/**
+ * @param {Request} request
+ */
+async function handler(request) {
+  return new Response(
+    JSON.stringify({ message: "Hello from GET /api/example" }),
+    { headers: { "Content-Type": "application/json" } }
+  );
+}
+
+export default withMiddleware(logMethodMiddleware, handler);
+```
+
+Each middleware function may:
+
+- Return a `Response` to stop execution
+- Return a new `Request` to continue with a modified request
+- Return nothing to pass the request through unchanged
+
+The final handler **must** return a `Response`.
+
+---
+
+## Client
+
+The client side of Attay provides a file-based router for **Preact**, built on `preact-iso`.
+
+Pages are discovered using Vite’s `import.meta.glob`, lazy-loaded, and mapped to routes using simple conventions.
+
+```jsx
+import { render } from "preact";
+import { LocationProvider } from "preact-iso";
+import RouterView from "attay/client";
+
+render(
+  <LocationProvider>
+    <RouterView />
+  </LocationProvider>,
+  document.getElementById("app")!
+);
+```
+
+By default, pages live in `src/pages`, but you can fully control discovery by passing your own glob map.
+
+#### Custom pages directory
+
+If you don’t want to use `src/pages`, you can pass your own Vite glob map to `RouterView`.
+
+```jsx
+import { render } from "preact";
+import { LocationProvider } from "preact-iso";
+import RouterView from "attay/client";
+
+const pages = import.meta.glob("/src/features/blog/pages/**/!(_)*.{tsx,jsx}");
+
+render(
+  <LocationProvider>
+    <RouterView pages={pages} />
+  </LocationProvider>,
+  document.getElementById("app")!
+);
+```
+
+This keeps page discovery fully static and bundler-friendly, while letting you organize your app however you want.
+
+### useRouter()
+
+`useRouter()` is a small convenience hook built on top of `preact-iso`.
+
+It exposes the current routing state and a simple navigation helper without hiding how routing actually works.
+
+```js
+import { useRouter } from "attay/client";
+
+export default function UserPage() {
+  const { params, query, push } = useRouter();
+
+  return (
+    <div>
+      <p>User ID: {params.id}</p>
+      <button onClick={() => push("/?from=user")}>Go home</button>
+    </div>
+  );
+}
+```
+
+What it gives you:
+
+- `params` — dynamic route parameters
+- `query` — parsed query string values
+- `push(url, replace?)` — programmatic navigation
+- `currentPath` and `url` for introspection

package/dist/client/index.d.ts

@@ -0,0 +1,28 @@
+import { ComponentType, JSX } from 'preact';
+
+type AnyComponent = ComponentType<any>;
+type PageModule = {
+    default: AnyComponent;
+} & Record<string, unknown>;
+type Loader = () => Promise<PageModule>;
+type PagesGlob = Record<string, Loader>;
+interface RouterViewProps {
+    pages?: PagesGlob;
+}
+declare function RouterView({ pages }: RouterViewProps): JSX.Element;
+
+interface RouterLike {
+    push: (url: string, replace?: boolean) => void;
+    query: Record<string, string>;
+    params: Record<string, string>;
+    currentPath: string;
+    url: string;
+}
+/**
+ * Router hook backed by preact-iso.
+ *
+ * @returns {RouterLike}
+ */
+declare function useRouter(): RouterLike;
+
+export { type PagesGlob, type RouterLike, RouterView, type RouterViewProps, RouterView as default, useRouter };

package/dist/client/index.js

@@ -0,0 +1,60 @@
+// src/client/RouterView.tsx
+import { ErrorBoundary, Router, Route, lazy } from "preact-iso";
+import { jsx, jsxs } from "preact/jsx-runtime";
+var DEFAULT_PAGES = import.meta.glob(
+  "/src/pages/**/!(_)*.{tsx,jsx}"
+);
+function pathToIsoPattern(key) {
+  let routePath = key.replace(/^\.\.\/pages/, "").replace(/\.(t|j)sx$/, "");
+  if (routePath.endsWith("/index")) {
+    routePath = routePath.replace(/\/index$/, "") || "/";
+  }
+  routePath = routePath.replace(/\[\.\.\.([^/\]]+)\]/g, ":$1*");
+  routePath = routePath.replace(/\[([^/\]]+)\]/g, ":$1");
+  return routePath;
+}
+function toLazyModule(loader) {
+  return async () => {
+    const mod = await loader();
+    return { default: mod.default };
+  };
+}
+function RouterView({ pages = DEFAULT_PAGES }) {
+  const entries = Object.entries(pages).filter(
+    ([key]) => !key.includes("/pages/api/")
+  );
+  const notFoundEntry = entries.find(([key]) => /\/404\.(t|j)sx$/.test(key));
+  const routes = entries.filter(([key]) => !/\/404\.(t|j)sx$/.test(key)).map(([key, loader]) => {
+    const path = pathToIsoPattern(key);
+    const Component = lazy(toLazyModule(loader));
+    return /* @__PURE__ */ jsx(Route, { path, component: Component }, key);
+  });
+  const NotFound = notFoundEntry ? lazy(toLazyModule(notFoundEntry[1])) : function NotFoundFallback() {
+    return /* @__PURE__ */ jsx("p", { children: "no route found" });
+  };
+  return /* @__PURE__ */ jsx(ErrorBoundary, { children: /* @__PURE__ */ jsxs(Router, { children: [
+    routes,
+    /* @__PURE__ */ jsx(Route, { default: true, component: NotFound })
+  ] }) });
+}
+var RouterView_default = RouterView;
+
+// src/client/router.tsx
+import { useLocation, useRoute } from "preact-iso";
+function useRouter() {
+  const location = useLocation();
+  const route = useRoute();
+  return {
+    push: (url, replace) => location.route(url, replace),
+    query: route.query,
+    params: route.params,
+    currentPath: route.path,
+    url: location.url
+  };
+}
+export {
+  RouterView_default as RouterView,
+  RouterView_default as default,
+  useRouter
+};
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/client/RouterView.tsx","../../src/client/router.tsx"],"sourcesContent":["/// <reference types=\"vite/client\" />\nimport { ErrorBoundary, Router, Route, lazy } from \"preact-iso\";\nimport type { ComponentType, JSX } from \"preact\";\n\ntype AnyComponent = ComponentType<any>;\n\ntype PageModule = { default: AnyComponent } & Record<string, unknown>;\n\ntype Loader = () => Promise<PageModule>;\n\nexport type PagesGlob = Record<string, Loader>;\n\nexport interface RouterViewProps {\n  pages?: PagesGlob;\n}\n\nconst DEFAULT_PAGES = import.meta.glob(\n  \"/src/pages/**/!(_)*.{tsx,jsx}\",\n) as PagesGlob;\n\nfunction pathToIsoPattern(key: string): string {\n  let routePath = key.replace(/^\\.\\.\\/pages/, \"\").replace(/\\.(t|j)sx$/, \"\");\n\n  if (routePath.endsWith(\"/index\")) {\n    routePath = routePath.replace(/\\/index$/, \"\") || \"/\";\n  }\n\n  routePath = routePath.replace(/\\[\\.\\.\\.([^/\\]]+)\\]/g, \":$1*\");\n  routePath = routePath.replace(/\\[([^/\\]]+)\\]/g, \":$1\");\n\n  return routePath;\n}\n\nfunction toLazyModule(loader: Loader): () => Promise<{ default: AnyComponent }> {\n  return async () => {\n    const mod = await loader();\n    return { default: mod.default };\n  };\n}\n\nfunction RouterView({ pages = DEFAULT_PAGES }: RouterViewProps): JSX.Element {\n  const entries = Object.entries(pages).filter(\n    ([key]) => !key.includes(\"/pages/api/\"),\n  );\n\n  const notFoundEntry = entries.find(([key]) => /\\/404\\.(t|j)sx$/.test(key));\n\n  const routes = entries\n    .filter(([key]) => !/\\/404\\.(t|j)sx$/.test(key))\n    .map(([key, loader]) => {\n      const path = pathToIsoPattern(key);\n      const Component = lazy(toLazyModule(loader));\n      return <Route key={key} path={path} component={Component} />;\n    });\n\n  const NotFound = notFoundEntry\n    ? lazy(toLazyModule(notFoundEntry[1]))\n    : function NotFoundFallback() {\n        return <p>no route found</p>;\n      };\n\n  return (\n    <ErrorBoundary>\n      <Router>\n        {routes}\n        <Route default component={NotFound} />\n      </Router>\n    </ErrorBoundary>\n  );\n}\n\nexport default RouterView;\n","import { useLocation, useRoute } from \"preact-iso\";\n\nexport interface RouterLike {\n  push: (url: string, replace?: boolean) => void;\n  query: Record<string, string>;\n  params: Record<string, string>;\n  currentPath: string;\n  url: string;\n}\n\n/**\n * Router hook backed by preact-iso.\n *\n * @returns {RouterLike}\n */\nexport function useRouter(): RouterLike {\n  const location = useLocation();\n  const route = useRoute();\n\n  return {\n    push: (url, replace) => location.route(url, replace),\n    query: route.query,\n    params: route.params,\n    currentPath: route.path,\n    url: location.url,\n  };\n}\n\nexport default useRouter;\n"],"mappings":";AACA,SAAS,eAAe,QAAQ,OAAO,YAAY;AAmDtC,cAWP,YAXO;AApCb,IAAM,gBAAgB,YAAY;AAAA,EAChC;AACF;AAEA,SAAS,iBAAiB,KAAqB;AAC7C,MAAI,YAAY,IAAI,QAAQ,gBAAgB,EAAE,EAAE,QAAQ,cAAc,EAAE;AAExE,MAAI,UAAU,SAAS,QAAQ,GAAG;AAChC,gBAAY,UAAU,QAAQ,YAAY,EAAE,KAAK;AAAA,EACnD;AAEA,cAAY,UAAU,QAAQ,wBAAwB,MAAM;AAC5D,cAAY,UAAU,QAAQ,kBAAkB,KAAK;AAErD,SAAO;AACT;AAEA,SAAS,aAAa,QAA0D;AAC9E,SAAO,YAAY;AACjB,UAAM,MAAM,MAAM,OAAO;AACzB,WAAO,EAAE,SAAS,IAAI,QAAQ;AAAA,EAChC;AACF;AAEA,SAAS,WAAW,EAAE,QAAQ,cAAc,GAAiC;AAC3E,QAAM,UAAU,OAAO,QAAQ,KAAK,EAAE;AAAA,IACpC,CAAC,CAAC,GAAG,MAAM,CAAC,IAAI,SAAS,aAAa;AAAA,EACxC;AAEA,QAAM,gBAAgB,QAAQ,KAAK,CAAC,CAAC,GAAG,MAAM,kBAAkB,KAAK,GAAG,CAAC;AAEzE,QAAM,SAAS,QACZ,OAAO,CAAC,CAAC,GAAG,MAAM,CAAC,kBAAkB,KAAK,GAAG,CAAC,EAC9C,IAAI,CAAC,CAAC,KAAK,MAAM,MAAM;AACtB,UAAM,OAAO,iBAAiB,GAAG;AACjC,UAAM,YAAY,KAAK,aAAa,MAAM,CAAC;AAC3C,WAAO,oBAAC,SAAgB,MAAY,WAAW,aAA5B,GAAuC;AAAA,EAC5D,CAAC;AAEH,QAAM,WAAW,gBACb,KAAK,aAAa,cAAc,CAAC,CAAC,CAAC,IACnC,SAAS,mBAAmB;AAC1B,WAAO,oBAAC,OAAE,4BAAc;AAAA,EAC1B;AAEJ,SACE,oBAAC,iBACC,+BAAC,UACE;AAAA;AAAA,IACD,oBAAC,SAAM,SAAO,MAAC,WAAW,UAAU;AAAA,KACtC,GACF;AAEJ;AAEA,IAAO,qBAAQ;;;ACvEf,SAAS,aAAa,gBAAgB;AAe/B,SAAS,YAAwB;AACtC,QAAM,WAAW,YAAY;AAC7B,QAAM,QAAQ,SAAS;AAEvB,SAAO;AAAA,IACL,MAAM,CAAC,KAAK,YAAY,SAAS,MAAM,KAAK,OAAO;AAAA,IACnD,OAAO,MAAM;AAAA,IACb,QAAQ,MAAM;AAAA,IACd,aAAa,MAAM;AAAA,IACnB,KAAK,SAAS;AAAA,EAChB;AACF;","names":[]}

package/dist/server/index.d.ts

@@ -0,0 +1,30 @@
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+type RouteHandler = (req: Request) => Response | Promise<Response>;
+type MiddlewareResult = Response | Request | void;
+type Middleware = (req: Request) => MiddlewareResult | Promise<MiddlewareResult>;
+type MethodHandlers = Partial<Record<HttpMethod, RouteHandler>>;
+type BunRouteValue = Response | ReturnType<typeof Bun.file> | RouteHandler | MethodHandlers;
+type BunRoutes = Record<string, BunRouteValue>;
+interface AttayRoutesOptions {
+    /** Directory that contains your API route files. Defaults to `${process.cwd()}/api`. */
+    dir?: string;
+    /** Vite build output directory (usually `./client/dist`). If provided, Attay serves assets + SPA fallback. */
+    client?: string;
+}
+/**
+ * Wrap a final route handler with one or more middleware functions.
+ *
+ * Each middleware can:
+ *  - return a Response to end the chain
+ *  - return a Request to continue with a modified request
+ *  - return void to pass the current request through
+ */
+declare function withMiddleware(...fns: [...Middleware[], RouteHandler]): RouteHandler;
+/**
+ * Create a Bun `routes` table by scanning an API directory and (optionally) wiring up
+ * Vite client static assets + SPA fallback.
+ */
+declare function attayRoutes(options?: AttayRoutesOptions): Promise<BunRoutes>;
+declare const attayRoutesAsync: typeof attayRoutes;
+
+export { type AttayRoutesOptions, type BunRouteValue, type BunRoutes, type HttpMethod, type MethodHandlers, type Middleware, type MiddlewareResult, type RouteHandler, attayRoutesAsync, attayRoutes as default, withMiddleware };

package/dist/server/index.js

@@ -0,0 +1,139 @@
+// src/server/index.ts
+import fs from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+function withMiddleware(...fns) {
+  return async (req) => {
+    let current = req;
+    for (let i = 0; i < fns.length - 1; i++) {
+      const r = await fns[i](current);
+      if (r instanceof Response) return r;
+      if (r instanceof Request) current = r;
+    }
+    const final = await fns[fns.length - 1](current);
+    if (!(final instanceof Response)) {
+      throw new Error("Final handler must return Response");
+    }
+    return final;
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function isHttpMethod(x) {
+  return x === "GET" || x === "POST" || x === "PUT" || x === "DELETE" || x === "PATCH";
+}
+function normalizeRouteSegment(seg) {
+  const m1 = seg.match(/^\[([^\]/]+)\]$/);
+  if (m1) return `:${m1[1]}`;
+  const m2 = seg.match(/^\[\.\.\.([^\]/]+)\]$/);
+  if (m2) return "*";
+  return seg;
+}
+function toRoutePath(routeBase) {
+  const clean = routeBase.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!clean) return "/";
+  const parts = clean.split("/").filter(Boolean).map(normalizeRouteSegment);
+  return "/" + parts.join("/");
+}
+async function fileExists(filePath) {
+  try {
+    const stat = await fs.stat(filePath);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+function contentTypeFor(filePath) {
+  const ext = path.extname(filePath);
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+async function attayRoutes(options = {}) {
+  const routes = {};
+  const dir = options.dir ? path.isAbsolute(options.dir) ? options.dir : path.join(process.cwd(), options.dir) : path.join(process.cwd(), "api");
+  const clientDir = options.client ? path.isAbsolute(options.client) ? options.client : path.join(process.cwd(), options.client) : null;
+  async function registerApi(dirPath, routeBase = "") {
+    let entries;
+    try {
+      entries = await fs.readdir(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        await registerApi(entryPath, routeBase + "/" + entry.name);
+        continue;
+      }
+      if (!/\.(ts|js)$/.test(entry.name)) continue;
+      if (entry.name.startsWith("_")) continue;
+      const name = path.basename(entry.name).replace(/\.(ts|js)$/, "");
+      const upper = name.toUpperCase();
+      if (!isHttpMethod(upper)) continue;
+      const mod = await import(pathToFileURL(entryPath).href);
+      const handler = mod?.default;
+      if (typeof handler !== "function") continue;
+      const routePath = toRoutePath(routeBase);
+      const existing = routes[routePath];
+      if (existing && typeof existing === "object" && !(existing instanceof Response)) {
+        const asMethods = existing;
+        if ("GET" in asMethods || "POST" in asMethods || "PUT" in asMethods || "DELETE" in asMethods || "PATCH" in asMethods) {
+          asMethods[upper] = handler;
+          routes[routePath] = asMethods;
+          continue;
+        }
+      }
+      routes[routePath] = { [upper]: handler };
+    }
+  }
+  await registerApi(dir);
+  if (clientDir) {
+    const indexHtmlPath = path.join(clientDir, "index.html");
+    const serveClient = async (req) => {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+      const method = req.method.toUpperCase();
+      if (method !== "GET" && method !== "HEAD") {
+        return new Response("Not found", { status: 404 });
+      }
+      const safePath = pathname.replace(/^\/+/, "");
+      const filePath = safePath === "" ? indexHtmlPath : path.join(clientDir, safePath);
+      if (await fileExists(filePath)) {
+        const file = Bun.file(filePath);
+        return new Response(file, {
+          headers: {
+            "Content-Type": contentTypeFor(filePath)
+          }
+        });
+      }
+      const indexFile = Bun.file(indexHtmlPath);
+      return new Response(indexFile, {
+        headers: {
+          "Content-Type": "text/html; charset=utf-8"
+        }
+      });
+    };
+    routes["/*"] = serveClient;
+  }
+  return routes;
+}
+var attayRoutesAsync = attayRoutes;
+export {
+  attayRoutesAsync,
+  attayRoutes as default,
+  withMiddleware
+};
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/server/index.ts"],"sourcesContent":["import fs from \"fs/promises\";\nimport path from \"path\";\nimport { pathToFileURL } from \"url\";\n\nexport type HttpMethod = \"GET\" | \"POST\" | \"PUT\" | \"DELETE\" | \"PATCH\";\n\nexport type RouteHandler = (req: Request) => Response | Promise<Response>;\n\nexport type MiddlewareResult = Response | Request | void;\nexport type Middleware = (\n  req: Request\n) => MiddlewareResult | Promise<MiddlewareResult>;\n\nexport type MethodHandlers = Partial<Record<HttpMethod, RouteHandler>>;\n\n// Bun's `routes` accepts values like Response, Bun.file(), handler functions, or per-method handlers.\n// We keep this intentionally broad so Attay can return what Bun expects.\nexport type BunRouteValue =\n  | Response\n  | ReturnType<typeof Bun.file>\n  | RouteHandler\n  | MethodHandlers;\nexport type BunRoutes = Record<string, BunRouteValue>;\n\nexport interface AttayRoutesOptions {\n  /** Directory that contains your API route files. Defaults to `${process.cwd()}/api`. */\n  dir?: string;\n  /** Vite build output directory (usually `./client/dist`). If provided, Attay serves assets + SPA fallback. */\n  client?: string;\n}\n\n/**\n * Wrap a final route handler with one or more middleware functions.\n *\n * Each middleware can:\n *  - return a Response to end the chain\n *  - return a Request to continue with a modified request\n *  - return void to pass the current request through\n */\nexport function withMiddleware(\n  ...fns: [...Middleware[], RouteHandler]\n): RouteHandler {\n  return async (req: Request) => {\n    let current: Request = req;\n\n    for (let i = 0; i < fns.length - 1; i++) {\n      const r = await fns[i](current);\n      if (r instanceof Response) return r;\n      if (r instanceof Request) current = r;\n    }\n\n    const final = await fns[fns.length - 1](current);\n    if (!(final instanceof Response)) {\n      throw new Error(\"Final handler must return Response\");\n    }\n    return final;\n  };\n}\n\n/** Very small mime map for common frontend assets. */\nconst MIME_TYPES: Record<string, string> = {\n  \".html\": \"text/html; charset=utf-8\",\n  \".js\": \"text/javascript; charset=utf-8\",\n  \".mjs\": \"text/javascript; charset=utf-8\",\n  \".css\": \"text/css; charset=utf-8\",\n  \".json\": \"application/json; charset=utf-8\",\n  \".png\": \"image/png\",\n  \".jpg\": \"image/jpeg\",\n  \".jpeg\": \"image/jpeg\",\n  \".gif\": \"image/gif\",\n  \".svg\": \"image/svg+xml\",\n  \".ico\": \"image/x-icon\",\n  \".woff\": \"font/woff\",\n  \".woff2\": \"font/woff2\",\n  \".ttf\": \"font/ttf\",\n};\n\nfunction isHttpMethod(x: string): x is HttpMethod {\n  return (\n    x === \"GET\" ||\n    x === \"POST\" ||\n    x === \"PUT\" ||\n    x === \"DELETE\" ||\n    x === \"PATCH\"\n  );\n}\n\nfunction normalizeRouteSegment(seg: string): string {\n  // [id] -> :id\n  const m1 = seg.match(/^\\[([^\\]/]+)\\]$/);\n  if (m1) return `:${m1[1]}`;\n\n  // [...slug] -> * (Bun wildcard)\n  const m2 = seg.match(/^\\[\\.\\.\\.([^\\]/]+)\\]$/);\n  if (m2) return \"*\";\n\n  return seg;\n}\n\nfunction toRoutePath(routeBase: string): string {\n  // routeBase comes in like \"\" or \"/users/[id]\"\n  const clean = routeBase.replace(/^\\/+/, \"\").replace(/\\/+$/, \"\");\n  if (!clean) return \"/\";\n\n  const parts = clean.split(\"/\").filter(Boolean).map(normalizeRouteSegment);\n\n  return \"/\" + parts.join(\"/\");\n}\n\nasync function fileExists(filePath: string): Promise<boolean> {\n  try {\n    const stat = await fs.stat(filePath);\n    return stat.isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction contentTypeFor(filePath: string): string {\n  const ext = path.extname(filePath);\n  return MIME_TYPES[ext] || \"application/octet-stream\";\n}\n\n/**\n * Create a Bun `routes` table by scanning an API directory and (optionally) wiring up\n * Vite client static assets + SPA fallback.\n */\nexport default async function attayRoutes(\n  options: AttayRoutesOptions = {}\n): Promise<BunRoutes> {\n  const routes: BunRoutes = {};\n\n  const dir = options.dir\n    ? path.isAbsolute(options.dir)\n      ? options.dir\n      : path.join(process.cwd(), options.dir)\n    : path.join(process.cwd(), \"api\");\n\n  const clientDir = options.client\n    ? path.isAbsolute(options.client)\n      ? options.client\n      : path.join(process.cwd(), options.client)\n    : null;\n\n  async function registerApi(dirPath: string, routeBase = \"\"): Promise<void> {\n    let entries: Array<import(\"fs\").Dirent>;\n    try {\n      entries = await fs.readdir(dirPath, { withFileTypes: true });\n    } catch {\n      // dir may not exist; that's ok\n      return;\n    }\n\n    for (const entry of entries) {\n      const entryPath = path.join(dirPath, entry.name);\n\n      if (entry.isDirectory()) {\n        await registerApi(entryPath, routeBase + \"/\" + entry.name);\n        continue;\n      }\n\n      if (!/\\.(ts|js)$/.test(entry.name)) continue;\n      if (entry.name.startsWith(\"_\")) continue;\n\n      const name = path.basename(entry.name).replace(/\\.(ts|js)$/, \"\");\n      const upper = name.toUpperCase();\n      if (!isHttpMethod(upper)) continue;\n\n      const mod = await import(pathToFileURL(entryPath).href);\n      const handler = mod?.default;\n      if (typeof handler !== \"function\") continue;\n\n      const routePath = toRoutePath(routeBase);\n\n      const existing = routes[routePath];\n      if (\n        existing &&\n        typeof existing === \"object\" &&\n        !(existing instanceof Response)\n      ) {\n        const asMethods = existing as MethodHandlers;\n        if (\n          \"GET\" in asMethods ||\n          \"POST\" in asMethods ||\n          \"PUT\" in asMethods ||\n          \"DELETE\" in asMethods ||\n          \"PATCH\" in asMethods\n        ) {\n          asMethods[upper] = handler as RouteHandler;\n          routes[routePath] = asMethods;\n          continue;\n        }\n      }\n\n      routes[routePath] = { [upper]: handler as RouteHandler };\n    }\n  }\n\n  await registerApi(dir);\n\n  if (clientDir) {\n    const indexHtmlPath = path.join(clientDir, \"index.html\");\n\n    const serveClient: RouteHandler = async (req: Request) => {\n      const url = new URL(req.url);\n      const pathname = url.pathname;\n      const method = req.method.toUpperCase();\n\n      if (method !== \"GET\" && method !== \"HEAD\") {\n        return new Response(\"Not found\", { status: 404 });\n      }\n\n      const safePath = pathname.replace(/^\\/+/, \"\");\n      const filePath =\n        safePath === \"\" ? indexHtmlPath : path.join(clientDir, safePath);\n\n      if (await fileExists(filePath)) {\n        const file = Bun.file(filePath);\n        return new Response(file, {\n          headers: {\n            \"Content-Type\": contentTypeFor(filePath),\n          },\n        });\n      }\n\n      const indexFile = Bun.file(indexHtmlPath);\n      return new Response(indexFile, {\n        headers: {\n          \"Content-Type\": \"text/html; charset=utf-8\",\n        },\n      });\n    };\n\n    routes[\"/*\"] = serveClient;\n  }\n\n  return routes;\n}\n\nexport const attayRoutesAsync = attayRoutes;\n"],"mappings":";AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,SAAS,qBAAqB;AAqCvB,SAAS,kBACX,KACW;AACd,SAAO,OAAO,QAAiB;AAC7B,QAAI,UAAmB;AAEvB,aAAS,IAAI,GAAG,IAAI,IAAI,SAAS,GAAG,KAAK;AACvC,YAAM,IAAI,MAAM,IAAI,CAAC,EAAE,OAAO;AAC9B,UAAI,aAAa,SAAU,QAAO;AAClC,UAAI,aAAa,QAAS,WAAU;AAAA,IACtC;AAEA,UAAM,QAAQ,MAAM,IAAI,IAAI,SAAS,CAAC,EAAE,OAAO;AAC/C,QAAI,EAAE,iBAAiB,WAAW;AAChC,YAAM,IAAI,MAAM,oCAAoC;AAAA,IACtD;AACA,WAAO;AAAA,EACT;AACF;AAGA,IAAM,aAAqC;AAAA,EACzC,SAAS;AAAA,EACT,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,QAAQ;AACV;AAEA,SAAS,aAAa,GAA4B;AAChD,SACE,MAAM,SACN,MAAM,UACN,MAAM,SACN,MAAM,YACN,MAAM;AAEV;AAEA,SAAS,sBAAsB,KAAqB;AAElD,QAAM,KAAK,IAAI,MAAM,iBAAiB;AACtC,MAAI,GAAI,QAAO,IAAI,GAAG,CAAC,CAAC;AAGxB,QAAM,KAAK,IAAI,MAAM,uBAAuB;AAC5C,MAAI,GAAI,QAAO;AAEf,SAAO;AACT;AAEA,SAAS,YAAY,WAA2B;AAE9C,QAAM,QAAQ,UAAU,QAAQ,QAAQ,EAAE,EAAE,QAAQ,QAAQ,EAAE;AAC9D,MAAI,CAAC,MAAO,QAAO;AAEnB,QAAM,QAAQ,MAAM,MAAM,GAAG,EAAE,OAAO,OAAO,EAAE,IAAI,qBAAqB;AAExE,SAAO,MAAM,MAAM,KAAK,GAAG;AAC7B;AAEA,eAAe,WAAW,UAAoC;AAC5D,MAAI;AACF,UAAM,OAAO,MAAM,GAAG,KAAK,QAAQ;AACnC,WAAO,KAAK,OAAO;AAAA,EACrB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,eAAe,UAA0B;AAChD,QAAM,MAAM,KAAK,QAAQ,QAAQ;AACjC,SAAO,WAAW,GAAG,KAAK;AAC5B;AAMA,eAAO,YACL,UAA8B,CAAC,GACX;AACpB,QAAM,SAAoB,CAAC;AAE3B,QAAM,MAAM,QAAQ,MAChB,KAAK,WAAW,QAAQ,GAAG,IACzB,QAAQ,MACR,KAAK,KAAK,QAAQ,IAAI,GAAG,QAAQ,GAAG,IACtC,KAAK,KAAK,QAAQ,IAAI,GAAG,KAAK;AAElC,QAAM,YAAY,QAAQ,SACtB,KAAK,WAAW,QAAQ,MAAM,IAC5B,QAAQ,SACR,KAAK,KAAK,QAAQ,IAAI,GAAG,QAAQ,MAAM,IACzC;AAEJ,iBAAe,YAAY,SAAiB,YAAY,IAAmB;AACzE,QAAI;AACJ,QAAI;AACF,gBAAU,MAAM,GAAG,QAAQ,SAAS,EAAE,eAAe,KAAK,CAAC;AAAA,IAC7D,QAAQ;AAEN;AAAA,IACF;AAEA,eAAW,SAAS,SAAS;AAC3B,YAAM,YAAY,KAAK,KAAK,SAAS,MAAM,IAAI;AAE/C,UAAI,MAAM,YAAY,GAAG;AACvB,cAAM,YAAY,WAAW,YAAY,MAAM,MAAM,IAAI;AACzD;AAAA,MACF;AAEA,UAAI,CAAC,aAAa,KAAK,MAAM,IAAI,EAAG;AACpC,UAAI,MAAM,KAAK,WAAW,GAAG,EAAG;AAEhC,YAAM,OAAO,KAAK,SAAS,MAAM,IAAI,EAAE,QAAQ,cAAc,EAAE;AAC/D,YAAM,QAAQ,KAAK,YAAY;AAC/B,UAAI,CAAC,aAAa,KAAK,EAAG;AAE1B,YAAM,MAAM,MAAM,OAAO,cAAc,SAAS,EAAE;AAClD,YAAM,UAAU,KAAK;AACrB,UAAI,OAAO,YAAY,WAAY;AAEnC,YAAM,YAAY,YAAY,SAAS;AAEvC,YAAM,WAAW,OAAO,SAAS;AACjC,UACE,YACA,OAAO,aAAa,YACpB,EAAE,oBAAoB,WACtB;AACA,cAAM,YAAY;AAClB,YACE,SAAS,aACT,UAAU,aACV,SAAS,aACT,YAAY,aACZ,WAAW,WACX;AACA,oBAAU,KAAK,IAAI;AACnB,iBAAO,SAAS,IAAI;AACpB;AAAA,QACF;AAAA,MACF;AAEA,aAAO,SAAS,IAAI,EAAE,CAAC,KAAK,GAAG,QAAwB;AAAA,IACzD;AAAA,EACF;AAEA,QAAM,YAAY,GAAG;AAErB,MAAI,WAAW;AACb,UAAM,gBAAgB,KAAK,KAAK,WAAW,YAAY;AAEvD,UAAM,cAA4B,OAAO,QAAiB;AACxD,YAAM,MAAM,IAAI,IAAI,IAAI,GAAG;AAC3B,YAAM,WAAW,IAAI;AACrB,YAAM,SAAS,IAAI,OAAO,YAAY;AAEtC,UAAI,WAAW,SAAS,WAAW,QAAQ;AACzC,eAAO,IAAI,SAAS,aAAa,EAAE,QAAQ,IAAI,CAAC;AAAA,MAClD;AAEA,YAAM,WAAW,SAAS,QAAQ,QAAQ,EAAE;AAC5C,YAAM,WACJ,aAAa,KAAK,gBAAgB,KAAK,KAAK,WAAW,QAAQ;AAEjE,UAAI,MAAM,WAAW,QAAQ,GAAG;AAC9B,cAAM,OAAO,IAAI,KAAK,QAAQ;AAC9B,eAAO,IAAI,SAAS,MAAM;AAAA,UACxB,SAAS;AAAA,YACP,gBAAgB,eAAe,QAAQ;AAAA,UACzC;AAAA,QACF,CAAC;AAAA,MACH;AAEA,YAAM,YAAY,IAAI,KAAK,aAAa;AACxC,aAAO,IAAI,SAAS,WAAW;AAAA,QAC7B,SAAS;AAAA,UACP,gBAAgB;AAAA,QAClB;AAAA,MACF,CAAC;AAAA,IACH;AAEA,WAAO,IAAI,IAAI;AAAA,EACjB;AAEA,SAAO;AACT;AAEO,IAAM,mBAAmB;","names":[]}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "attay",
+  "version": "0.0.1",
+  "description": "Helper utilities for Preact and Bun",
+  "license": "MIT",
+  "type": "module",
+  "author": {
+    "name": "Harshdeep Singh Hura",
+    "url": "https://harshdeephura.com"
+  },
+  "bugs": {
+    "url": "https://github.com/kinngh/attay/issues"
+  },
+  "homepage": "https://github.com/kinngh/attay#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kinngh/attay.git"
+  },
+  "exports": {
+    "./client": {
+      "types": "./dist/client/index.d.ts",
+      "import": "./dist/client/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "preact": "^10.0.0",
+    "preact-iso": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5",
+    "@types/node": "^25.0.3",
+    "preact": "^10.0.0",
+    "preact-iso": "^2.0.0",
+    "prettier": "^3.7.4",
+    "tsup": "^8.5.1",
+    "typescript": "^5.0.0",
+    "vite": "^7.3.0"
+  },
+  "scripts": {
+    "clean": "bun -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "typecheck": "tsc --noEmit",
+    "build": "bun run clean; bun run typecheck; tsup",
+    "pretty": "prettier --write ./"
+  }
+}