@boon4681/giri 0.0.3-alpha-3 → 0.0.3-alpha-5

package/README.md

@@ -228,6 +228,46 @@ yarn sync
 yarn dev
 ```
 
+## Portable runtime
+
+`@boon4681/giri/runtime` is the portable composition layer for generated integrations. It does
+not implement routing itself: it accepts a complete `GiriAdapter`, creates that adapter's app, and
+registers statically imported route modules. Hono is the supported adapter today:
+
+```ts
+import { createApp } from "@boon4681/giri/runtime";
+import { hono } from "@boon4681/giri/adapters/hono";
+import * as rootShared from "./src/routes/+shared";
+import * as usersGet from "./src/routes/users/+get";
+
+export const app = createApp({
+    adapter: hono(),
+    services: { source: "playground" },
+    routes: [
+        {
+            method: "GET",
+            path: "/api/users",
+            module: usersGet,
+            shared: [rootShared],
+        },
+    ],
+});
+```
+
+The result is a normal Fetch application:
+
+```ts
+const response = await app.fetch(new Request("https://example.test/api/users"));
+```
+
+`app` is the native Hono application, so SvelteKit or Next.js can forward a framework request
+directly to `app.fetch(request)`. This is the low-level target for virtual modules such as
+`@giri/project-1`; the Vite integration should generate the route descriptor array.
+
+The shipped Hono adapter also owns its Node server binding. A browser playground should provide a
+different `GiriAdapter` implementation whose `createApp`, `register`, `fetch`, and `serve` methods
+bind to the desired browser runtime; `createApp` itself does not special-case that environment.
+
 ## License
 
-MIT
+MIT

package/dist/adapters/hono.d.ts

@@ -1,5 +1,5 @@
 import { ContextVariableMap, Hono, MiddlewareHandler } from 'hono';
-import { M as Middleware, V as ValidatedInput, G as GiriAdapter } from '../types-BvRph0mx.js';
+import { M as Middleware, V as ValidatedInput, G as GiriAdapter } from '../types-DZ-14IP6.js';
 
 type HonoGiriApp = Hono;
 type HonoContextVars = {

package/dist/cli.js

@@ -688,6 +688,42 @@ function urlSegment(segment) {
   }
   return { value: segment };
 }
+function segmentRanks(segments) {
+  const ranks = [];
+  for (const segment of segments) {
+    const converted = urlSegment(segment);
+    if (!converted.value) {
+      continue;
+    }
+    if (converted.param?.catchAll) {
+      ranks.push({ rank: 2, text: converted.param.name });
+    } else if (converted.param) {
+      ranks.push({ rank: 1, text: converted.param.name });
+    } else {
+      ranks.push({ rank: 0, text: converted.value });
+    }
+  }
+  return ranks;
+}
+function compareRoutes(left, right) {
+  const leftRanks = segmentRanks(left.routeSegments);
+  const rightRanks = segmentRanks(right.routeSegments);
+  const shared = Math.min(leftRanks.length, rightRanks.length);
+  for (let i = 0; i < shared; i++) {
+    const a = leftRanks[i];
+    const b = rightRanks[i];
+    if (a.rank !== b.rank) {
+      return a.rank - b.rank;
+    }
+    if (a.rank === 0 && a.text !== b.text) {
+      return a.text.localeCompare(b.text);
+    }
+  }
+  if (leftRanks.length !== rightRanks.length) {
+    return leftRanks.length - rightRanks.length;
+  }
+  return METHOD_ORDER.indexOf(left.method) - METHOD_ORDER.indexOf(right.method);
+}
 function pathFromSegments(segments) {
   const pathSegments = [];
   const params = [];
@@ -764,13 +800,7 @@ async function scanRoutes(routesDir) {
       sharedFiles: sharedFilesForDir(routesDir, routeDir, sharedCache)
     });
   }
-  return routes.sort((left, right) => {
-    const pathOrder = left.path.localeCompare(right.path);
-    if (pathOrder !== 0) {
-      return pathOrder;
-    }
-    return METHOD_ORDER.indexOf(left.method) - METHOD_ORDER.indexOf(right.method);
-  });
+  return routes.sort(compareRoutes);
 }
 
 // src/types.ts