@ilha/router 0.10.0 → 0.10.2

package/dist/{plugin-CmI3Brr2.js → plugin-Bh0y5kkI.js}

@@ -1,4 +1,4 @@
-import { C as setLoaderGuard, T as runWithIslandRequest, b as setFrameAuth, c as frameEnvelope, m as isSafeFramePath, n as FrameError, o as authorizeFrameRequest, u as getFrameGuard, x as setFrameGuard, y as renderServerIsland } from "./ssr-BxrcUYy5.js";
+import { C as setLoaderGuard, T as runWithIslandRequest, b as setFrameAuth, c as frameEnvelope, m as isSafeFramePath, n as FrameError, o as authorizeFrameRequest, u as getFrameGuard, x as setFrameGuard, y as renderServerIsland } from "./ssr-CGcMUP1G.js";
 import { existsSync, readFileSync, statSync, watch } from "node:fs";
 import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { createUnplugin } from "unplugin";

package/dist/rsbuild.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-CmI3Brr2.js";
+import { t as ilhaPages } from "./plugin-Bh0y5kkI.js";
 
 //#region src/rsbuild.ts
 /** Rsbuild plugin — use via `@ilha/router/rsbuild`. */

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import "ilha";
+import { type ServerAction } from "ilha/internal";
+/**
+ * Declare an Oxide RPC action that can also be passed directly to server-island
+ * event props or bound to a serializable payload with `.with()`.
+ */
+export declare function action<A extends unknown[], R>(fn: (...args: A) => R): ServerAction<A, R>;
+export type { ServerAction } from "ilha/internal";

package/dist/server.js

@@ -0,0 +1,14 @@
+import "ilha";
+import { bindServerAction } from "ilha/internal";
+
+//#region src/server.ts
+/**
+* Declare an Oxide RPC action that can also be passed directly to server-island
+* event props or bound to a serializable payload with `.with()`.
+*/
+function action(fn) {
+	return bindServerAction(fn);
+}
+
+//#endregion
+export { action };

package/dist/{ssr-BxrcUYy5.js → ssr-CGcMUP1G.js}

@@ -1,5 +1,6 @@
 import { M as parsePattern, N as safeDecode, b as resolveRedirectTarget, j as matchSegments } from "./src-B5dHU24f.js";
-import { setServerManifestSerializer } from "ilha/internal";
+import "ilha";
+import { bindServerAction, setServerManifestSerializer } from "ilha/internal";
 import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/request-scope.ts
@@ -34,24 +35,6 @@ function runWithIslandRequest(request, fn) {
 
 //#endregion
 //#region src/ssr.ts
-/**
-* Production SSR endpoints for server-owned islands and regular-page loads.
-*
-* Default export is an oxidejs-style fetch middleware:
-* `(request) => Response | undefined`. Returns `undefined` for any request it
-* does not own, so hosts can chain it ahead of their own handler:
-*
-* ```ts
-* oxide({ middleware: ["@ilha/router/ssr"] });
-* ```
-*
-* Serves:
-* - `POST /__ilha/frame` — re-renders a server island (JSON `{ id, path }` in,
-*   `{ html }` out). Renderers come from the process-global registry
-*   populated by self-registration code appended to `.server` modules.
-* - `GET /__ilha/loader?path=…` — regular-page server loads via the loader
-*   runner (`setFrameLoaderRunner`, wired by the generated server module).
-*/
 const REGISTRY_KEY = Symbol.for("ilha.serverIslandRenderers");
 function registry() {
 	const g = globalThis;
@@ -191,15 +174,9 @@ function getFrameLoaderRunner() {
 setServerManifestSerializer({ template(manifest) {
 	return `<template data-ilha-actions='${JSON.stringify(Object.fromEntries(manifest)).replace(/&/g, "&amp;").replace(/'/g, "&#39;").replace(/</g, "&lt;")}'></template>`;
 } });
-/** Register `id` → entry. Later registrations win (id encodes file + name). */
-/**
-* Wrap an exported server action with a named transport key. Ilha never
-* executes event-handler closures during server rendering (fail closed), so
-* this is a transparent passthrough kept for API compatibility; the `key`
-* documents the RPC transport name used by tooling.
-*/
+/** @internal Brand an exported server action with its generated RPC transport key. */
 function __ilhaServerAction(key, fn) {
-	return typeof fn === "function" ? fn : () => fn;
+	return bindServerAction(fn, key);
 }
 function registerServerIsland(id, render, options) {
 	registry().set(id, {

package/dist/ssr.d.ts

@@ -16,6 +16,8 @@
  * - `GET /__ilha/loader?path=…` — regular-page server loads via the loader
  *   runner (`setFrameLoaderRunner`, wired by the generated server module).
  */
+import "ilha";
+import { type ServerAction } from "ilha/internal";
 import type { HeadInput } from "./head";
 /**
  * Server-frame state shared by the dev middleware and the production
@@ -143,14 +145,8 @@ export type FrameLoaderRunner = (path: string, request?: Request) => Promise<{
  */
 export declare function setFrameLoaderRunner(runner: FrameLoaderRunner): void;
 export declare function getFrameLoaderRunner(): FrameLoaderRunner | undefined;
-/** Register `id` → entry. Later registrations win (id encodes file + name). */
-/**
- * Wrap an exported server action with a named transport key. Ilha never
- * executes event-handler closures during server rendering (fail closed), so
- * this is a transparent passthrough kept for API compatibility; the `key`
- * documents the RPC transport name used by tooling.
- */
-export declare function __ilhaServerAction<A extends unknown[], R>(key: string, fn: (...args: A) => R): (...args: A) => R | undefined;
+/** @internal Brand an exported server action with its generated RPC transport key. */
+export declare function __ilhaServerAction<A extends unknown[], R>(key: string, fn: (...args: A) => R): ServerAction<A, R>;
 export declare function registerServerIsland(id: string, render: () => unknown, options?: {
     load?: ServerPageLoader;
     pattern?: string;

package/dist/ssr.js

@@ -1,3 +1,3 @@
-import { C as setLoaderGuard, S as setFrameLoaderRunner, _ as readBodyBounded, a as __ilhaServerAction, b as setFrameAuth, c as frameEnvelope, d as getFrameLoaderRunner, f as getLoaderGuard, g as json, h as isTrustedOrigin, i as MAX_BODY, l as getFrameAuth, m as isSafeFramePath, n as FrameError, o as authorizeFrameRequest, p as getServerIslandEntry, r as LOADER_ENDPOINT, s as forwardIdentityHeaders, t as FRAME_ENDPOINT, u as getFrameGuard, v as registerServerIsland, w as ssr, x as setFrameGuard, y as renderServerIsland } from "./ssr-BxrcUYy5.js";
+import { C as setLoaderGuard, S as setFrameLoaderRunner, _ as readBodyBounded, a as __ilhaServerAction, b as setFrameAuth, c as frameEnvelope, d as getFrameLoaderRunner, f as getLoaderGuard, g as json, h as isTrustedOrigin, i as MAX_BODY, l as getFrameAuth, m as isSafeFramePath, n as FrameError, o as authorizeFrameRequest, p as getServerIslandEntry, r as LOADER_ENDPOINT, s as forwardIdentityHeaders, t as FRAME_ENDPOINT, u as getFrameGuard, v as registerServerIsland, w as ssr, x as setFrameGuard, y as renderServerIsland } from "./ssr-CGcMUP1G.js";
 
 export { FRAME_ENDPOINT, FrameError, LOADER_ENDPOINT, MAX_BODY, __ilhaServerAction, authorizeFrameRequest, ssr as default, forwardIdentityHeaders, frameEnvelope, getFrameAuth, getFrameGuard, getFrameLoaderRunner, getLoaderGuard, getServerIslandEntry, isSafeFramePath, isTrustedOrigin, json, readBodyBounded, registerServerIsland, renderServerIsland, setFrameAuth, setFrameGuard, setFrameLoaderRunner, setLoaderGuard };

package/dist/vite.js

@@ -1,4 +1,4 @@
-import { t as ilhaPages } from "./plugin-CmI3Brr2.js";
+import { t as ilhaPages } from "./plugin-Bh0y5kkI.js";
 
 //#region src/vite.ts
 /** Vite plugin — use via `@ilha/router/vite`. */

package/oxlint.cjs

@@ -0,0 +1,428 @@
+const PASCAL_CASE = /^[A-Z][a-zA-Z0-9]*$/;
+const PRIMITIVES = new Set(["state", "derived", "action", "effect", "onError"]);
+const ACTION_STATUS = new Set(["pending", "data", "error"]);
+const CONDITIONAL = new Set([
+  "IfStatement",
+  "ForStatement",
+  "ForInStatement",
+  "ForOfStatement",
+  "WhileStatement",
+  "DoWhileStatement",
+  "SwitchStatement",
+  "ConditionalExpression",
+  "LogicalExpression",
+]);
+const FN_TYPES = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+
+function bindings() {
+  return { ilha: new Set(["ilha"]), prim: new Map() };
+}
+
+function takeImport(b, node) {
+  if (node.source.value !== "ilha") return;
+  for (const s of node.specifiers) {
+    if (s.type !== "ImportSpecifier") continue;
+    const imported = s.imported.name;
+    const local = s.local.name;
+    if (imported === "ilha") {
+      b.ilha.add(local);
+    }
+    if (PRIMITIVES.has(imported)) b.prim.set(local, imported);
+  }
+}
+
+function isIlhaCall(node, b) {
+  return (
+    node.type === "CallExpression" &&
+    node.callee.type === "Identifier" &&
+    b.ilha.has(node.callee.name)
+  );
+}
+
+function primitiveName(node, b) {
+  if (node.type !== "CallExpression") return null;
+  const c = node.callee;
+  if (c.type === "Identifier") return b.prim.get(c.name) ?? null;
+  const effectLocal = [...b.prim].find(([, n]) => n === "effect")?.[0];
+  if (
+    effectLocal &&
+    c.type === "MemberExpression" &&
+    !c.computed &&
+    c.object.type === "Identifier" &&
+    c.object.name === effectLocal &&
+    c.property.type === "Identifier" &&
+    c.property.name === "once"
+  ) {
+    return "effect.once";
+  }
+  return null;
+}
+
+function fnName(node, parent) {
+  if (node.id && node.id.type === "Identifier") return node.id.name;
+  if (parent?.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  return "";
+}
+
+function isComponentFn(node, parent, ancestors, b) {
+  const name = fnName(node, parent);
+  if (PASCAL_CASE.test(name)) return true;
+  if (parent?.type === "CallExpression" && isIlhaCall(parent, b)) return true;
+  const grand = ancestors?.[ancestors.length - 2];
+  return !!(grand && isIlhaCall(grand, b));
+}
+
+function ancestorsOf(context, node) {
+  const sc = context.sourceCode;
+  if (sc && typeof sc.getAncestors === "function") return sc.getAncestors(node);
+  return [];
+}
+
+function parentOf(context, node) {
+  const a = ancestorsOf(context, node);
+  return a[a.length - 1];
+}
+
+function toPascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+function calleeName(node) {
+  return node.type === "Identifier" ? node.name : null;
+}
+
+function collectIslands(b) {
+  const names = new Set();
+  return {
+    names,
+    VariableDeclarator(node) {
+      if (node.id.type === "Identifier" && node.init && isIlhaCall(node.init, b)) {
+        names.add(node.id.name);
+      }
+    },
+  };
+}
+
+function isInsideComponent(context, node, b) {
+  const ancestors = ancestorsOf(context, node);
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const a = ancestors[i];
+    if (!FN_TYPES.has(a.type)) continue;
+    const parent = i > 0 ? ancestors[i - 1] : null;
+    if (isComponentFn(a, parent, ancestors.slice(0, i), b)) return true;
+  }
+  return false;
+}
+
+function islandCallee(names, callee) {
+  if (callee.type === "Identifier" && names.has(callee.name)) return callee.name;
+  return null;
+}
+
+const pascalCase = {
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: { description: "Enforce PascalCase for ilha island variable names" },
+    messages: {
+      notPascalCase: 'Island variable "{{name}}" must be PascalCase (e.g. "{{suggested}}").',
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type === "Identifier" && node.init && isIlhaCall(node.init, b)) {
+          const name = node.id.name;
+          if (!PASCAL_CASE.test(name)) {
+            const suggested = toPascalCase(name);
+            context.report({
+              node: node.id,
+              messageId: "notPascalCase",
+              data: { name, suggested },
+              fix(fixer) {
+                return fixer.replaceText(node.id, suggested);
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};
+
+const noConditionalPrimitive = {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow primitives inside conditionals or loops" },
+    messages: {
+      conditional:
+        "Do not call {{name}}() inside a condition or loop. Put the branch inside the primitive.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      CallExpression(node) {
+        const name = primitiveName(node, b);
+        if (!name) return;
+        const ancestors = ancestorsOf(context, node);
+        for (let i = ancestors.length - 1; i >= 0; i--) {
+          const a = ancestors[i];
+          if (FN_TYPES.has(a.type)) return;
+          if (CONDITIONAL.has(a.type)) {
+            context.report({ node, messageId: "conditional", data: { name } });
+            return;
+          }
+        }
+      },
+    };
+  },
+};
+
+const noPrimitiveOutsideIsland = {
+  meta: {
+    type: "problem",
+    docs: { description: "Only call primitives in an island render or PascalCase component" },
+    messages: {
+      outside:
+        "Call {{name}}() only in an ilha() render or a PascalCase component. Put setup in effect.once().",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      CallExpression(node) {
+        const name = primitiveName(node, b);
+        if (!name) return;
+        const ancestors = ancestorsOf(context, node);
+        const fns = ancestors.filter((a) => FN_TYPES.has(a.type));
+        if (fns.length === 0) {
+          context.report({ node, messageId: "outside", data: { name } });
+          return;
+        }
+        const enclosing = fns[fns.length - 1];
+        const idx = ancestors.indexOf(enclosing);
+        const parent = idx > 0 ? ancestors[idx - 1] : parentOf(context, enclosing);
+        if (isComponentFn(enclosing, parent, ancestors.slice(0, idx), b)) return;
+        context.report({ node, messageId: "outside", data: { name } });
+      },
+    };
+  },
+};
+
+const preferPlainHandler = {
+  meta: {
+    type: "suggestion",
+    docs: { description: "Use a plain function unless action status or cancellation is used" },
+    messages: {
+      unused:
+        "action() is unused as a status object. Use a plain function unless you read .pending, .data, or .error.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    const found = new Map();
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier" || !node.init) return;
+        if (primitiveName(node.init, b) !== "action") return;
+        found.set(node.id.name, { node: node.init, used: false });
+      },
+      MemberExpression(node) {
+        if (node.computed || node.object.type !== "Identifier") return;
+        if (node.property.type !== "Identifier" || !ACTION_STATUS.has(node.property.name)) return;
+        const rec = found.get(node.object.name);
+        if (rec) rec.used = true;
+      },
+      "Program:exit"() {
+        for (const rec of found.values()) {
+          if (!rec.used) context.report({ node: rec.node, messageId: "unused" });
+        }
+      },
+    };
+  },
+};
+
+const preferLowercaseEvents = {
+  meta: {
+    type: "problem",
+    docs: { description: "Use lowercase DOM event props (onclick, not onClick)" },
+    messages: {
+      camel: 'Use lowercase event "{{suggested}}" instead of "{{name}}".',
+    },
+    schema: [],
+  },
+  create(context) {
+    function checkName(node, name) {
+      if (/^on[A-Z]/.test(name)) {
+        context.report({
+          node,
+          messageId: "camel",
+          data: { name, suggested: "on" + name.slice(2).toLowerCase() },
+        });
+      }
+    }
+    return {
+      JSXAttribute(node) {
+        const parent = parentOf(context, node);
+        const tag = parent && parent.name;
+        if (tag && tag.type === "JSXIdentifier" && PASCAL_CASE.test(tag.name)) return;
+        if (node.name.type === "JSXIdentifier") checkName(node.name, node.name.name);
+        if (node.name.type === "JSXNamespacedName") {
+          checkName(node.name.namespace, node.name.namespace.name);
+        }
+      },
+      TaggedTemplateExpression(node) {
+        if (node.tag.type !== "Identifier" || node.tag.name !== "html") return;
+        for (const q of node.quasi.quasis) {
+          const text = q.value.cooked ?? q.value.raw;
+          const re = /\bon[A-Z][A-Za-z]*/g;
+          let m;
+          while ((m = re.exec(text))) checkName(node, m[0]);
+        }
+      },
+    };
+  },
+};
+
+const noDirectIslandCall = {
+  meta: {
+    type: "problem",
+    docs: { description: "Only call islands as children inside another island render" },
+    messages: {
+      direct:
+        "Do not call {{name}}() here. Nest it inside another island, or use {{name}}.toString / toStringAsync / hydratable.",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    const { names, VariableDeclarator } = collectIslands(b);
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      VariableDeclarator,
+      CallExpression(node) {
+        const name = islandCallee(names, node.callee);
+        if (!name) return;
+        if (isInsideComponent(context, node, b)) return;
+        context.report({ node, messageId: "direct", data: { name } });
+      },
+    };
+  },
+};
+
+const requireSsrApi = {
+  meta: {
+    type: "problem",
+    docs: { description: "Use Island.toString / toStringAsync / hydratable for SSR" },
+    messages: {
+      awaitCall:
+        "Do not await {{name}}(). Use await {{name}}.toStringAsync() or await {{name}}.hydratable().",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    const { names, VariableDeclarator } = collectIslands(b);
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      VariableDeclarator,
+      AwaitExpression(node) {
+        const arg = node.argument;
+        if (arg.type !== "CallExpression") return;
+        const name = islandCallee(names, arg.callee);
+        if (name) context.report({ node, messageId: "awaitCall", data: { name } });
+      },
+    };
+  },
+};
+
+const functionInState = {
+  meta: {
+    type: "problem",
+    docs: { description: "Do not pass a function value to state() or a state setter" },
+    messages: {
+      init: "state({{name}}) treats the function as a lazy initializer. Wrap it: state(() => {{name}}).",
+      set: "{{setter}}({{name}}) runs as an updater. Store a function with {{setter}}(() => {{name}}).",
+    },
+    schema: [],
+  },
+  create(context) {
+    const b = bindings();
+    const fns = new Set();
+    const states = new Set();
+    return {
+      ImportDeclaration(node) {
+        takeImport(b, node);
+      },
+      FunctionDeclaration(node) {
+        if (node.id) fns.add(node.id.name);
+      },
+      VariableDeclarator(node) {
+        if (node.id.type !== "Identifier") return;
+        const init = node.init;
+        if (
+          init &&
+          (init.type === "FunctionExpression" || init.type === "ArrowFunctionExpression")
+        ) {
+          fns.add(node.id.name);
+        }
+        if (init && primitiveName(init, b) === "state") states.add(node.id.name);
+      },
+      CallExpression(node) {
+        if (node.arguments.length === 0) return;
+        const arg = node.arguments[0];
+        if (arg.type !== "Identifier" || !fns.has(arg.name)) return;
+        if (primitiveName(node, b) === "state") {
+          context.report({ node: arg, messageId: "init", data: { name: arg.name } });
+          return;
+        }
+        const setter = calleeName(node.callee);
+        if (setter && states.has(setter)) {
+          context.report({
+            node: arg,
+            messageId: "set",
+            data: { setter, name: arg.name },
+          });
+        }
+      },
+    };
+  },
+};
+
+module.exports = {
+  meta: { name: "oxlint-plugin-ilha" },
+  rules: {
+    "pascal-case": pascalCase,
+    "no-conditional-primitive": noConditionalPrimitive,
+    "no-primitive-outside-island": noPrimitiveOutsideIsland,
+    "prefer-plain-handler": preferPlainHandler,
+    "prefer-lowercase-events": preferLowercaseEvents,
+    "no-direct-island-call": noDirectIslandCall,
+    "require-ssr-api": requireSsrApi,
+    "function-in-state": functionInState,
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilha/router",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "A tiny SPA router for Ilha",
   "keywords": [
     "frontend",
@@ -26,7 +26,8 @@
     "url": "git+https://github.com/ilhajs/ilha.git"
   },
   "files": [
-    "dist"
+    "dist",
+    "oxlint.cjs"
   ],
   "type": "module",
   "sideEffects": false,
@@ -40,6 +41,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
     "./server-island": {
       "types": "./dist/server-island.d.ts",
       "import": "./dist/server-island.js"
@@ -55,7 +60,8 @@
     "./rsbuild": {
       "types": "./dist/rsbuild.d.ts",
       "import": "./dist/rsbuild.js"
-    }
+    },
+    "./oxlint": "./oxlint.cjs"
   },
   "publishConfig": {
     "access": "public"
@@ -69,10 +75,10 @@
     "unplugin": "3.3.0"
   },
   "devDependencies": {
-    "ilha": "0.12.0",
+    "ilha": "0.12.1",
     "vite": "^8.2.2"
   },
   "peerDependencies": {
-    "ilha": ">=0.12.0"
+    "ilha": ">=0.12.1"
   }
 }