weifuwu 0.25.2 → 0.27.0

package/dist/analytics.d.ts

@@ -1,45 +0,0 @@
-import type { Middleware, Closeable } from './types.ts';
-import { Router } from './router.ts';
-/** Tagged-template SQL function from the postgres.js library. */
-type PgSql = (strings: TemplateStringsArray, ...values: unknown[]) => Promise<unknown[]>;
-/** Schema table builder callback. */
-type PgTable = (name: string, cols: Record<string, unknown>) => {
-    create(): Promise<void>;
-    createIndex(cols: string[], opts: {
-        unique: boolean;
-    }): Promise<void>;
-};
-/** Options for {@link analytics}. */
-export interface AnalyticsOptions {
-    /** Path prefixes to exclude from analytics (default: `['/__analytics', '/__wfw', '/static']`). */
-    excluded?: string[];
-    /** PostgreSQL client for persistent storage. Required for production use. */
-    pg?: {
-        sql: PgSql;
-        table: PgTable;
-    };
-}
-/** Analytics module returned by {@link analytics}. */
-export interface AnalyticsModule extends Router, Closeable {
-    /** Middleware that records page views. */
-    middleware: () => Middleware;
-    /** Create/update the analytics database tables. */
-    migrate: () => Promise<void>;
-    /** Close the in-memory store and any timers. */
-    close: () => Promise<void>;
-}
-/**
- * Page view analytics module.
- *
- * Records page views with referrer and device type. Supports in-memory and PostgreSQL storage.
- * Provides a dashboard at `GET /__analytics`.
- *
- * ```ts
- * import { analytics, postgres } from 'weifuwu'
- *
- * const pg = postgres({ connection: DATABASE_URL })
- * app.use(analytics({ pg }).middleware())
- * ```
- */
-export declare function analytics(options?: AnalyticsOptions): AnalyticsModule;
-export {};

package/dist/auth.d.ts

@@ -1,22 +0,0 @@
-import type { Middleware } from './types.ts';
-export interface AuthOptions {
-    token?: string;
-    verify?: (token: string, req: Request) => unknown | Promise<unknown>;
-    proxy?: string | URL;
-    header?: string;
-    /**
-     * Enable session-based authentication.
-     * When true, auth() checks `ctx.session.userId` first.
-     * If found, the user is authenticated via session (no token required).
-     * Falls back to header-based auth if no session userId is present.
-     */
-    session?: boolean;
-    /**
-     * Function to load user data from a user ID stored in the session.
-     * Called when `session: true` and `ctx.session.userId` is present.
-     * Return a falsy value to reject (e.g. if the user was deleted).
-     * If not provided, `ctx.user` is set to `{ id: ctx.session.userId }`.
-     */
-    resolveUser?: (userId: unknown) => unknown | Promise<unknown>;
-}
-export declare function auth(options: AuthOptions): Middleware;

package/dist/cache.d.ts

@@ -1,74 +0,0 @@
-import type { Context, Middleware, Closeable } from './types.ts';
-import type { Redis } from './vendor.ts';
-export interface CachedResponse {
-    status: number;
-    statusText: string;
-    headers: Record<string, string>;
-    body: string;
-    createdAt: number;
-    tags: string[];
-}
-export interface CacheStore {
-    get(key: string): Promise<CachedResponse | null>;
-    set(key: string, entry: CachedResponse, ttl: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    invalidate(tag: string): Promise<void>;
-    flush(): Promise<void>;
-}
-export interface CacheOptions {
-    /** TTL in milliseconds. Default: 300_000 (5 min). */
-    ttl?: number;
-    /** Cache store. 'memory' (default) or 'redis'. */
-    store?: 'memory' | 'redis' | CacheStore;
-    /** Redis client (required when store: 'redis'). */
-    redis?: Redis;
-    /** Custom cache key function. Default: SHA256 of method + URL. */
-    key?: (req: Request) => string;
-    /** Tag function for grouped invalidation. Called after handler runs (ctx available). */
-    tag?: (req: Request, ctx: Context) => string | string[] | undefined;
-    /** Whether to cache responses with Set-Cookie. Default: false. */
-    cacheCookies?: boolean;
-    /** Status codes to cache. Default: [200]. */
-    cacheStatus?: number[];
-    /** Maximum number of bytes per cached body. Default: 1MB. Larger bodies are skipped. */
-    maxBodySize?: number;
-}
-export interface CacheMiddleware extends Middleware, Closeable {
-    /** Invalidate all entries with a given tag. */
-    invalidate(tag: string): Promise<void>;
-    /** Flush all cached entries. */
-    flush(): Promise<void>;
-    /** Cleanup. */
-    close(): Promise<void>;
-    /** Store reference (for testing). */
-    store: CacheStore;
-}
-export declare class MemoryCache implements CacheStore {
-    private store;
-    private tagIndex;
-    private interval;
-    constructor(cleanupMs?: number);
-    get(key: string): Promise<CachedResponse | null>;
-    set(key: string, data: CachedResponse, ttl: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    invalidate(tag: string): Promise<void>;
-    flush(): Promise<void>;
-    private cleanup;
-    close(): Promise<void>;
-    /** Testing only. */
-    get size(): number;
-}
-export declare class RedisCache implements CacheStore {
-    private redis;
-    private prefix;
-    private tagPrefix;
-    constructor(redis: Redis, prefix?: string);
-    private key;
-    private tagKey;
-    get(key: string): Promise<CachedResponse | null>;
-    set(key: string, entry: CachedResponse, ttl: number): Promise<void>;
-    delete(key: string): Promise<void>;
-    invalidate(tag: string): Promise<void>;
-    flush(): Promise<void>;
-}
-export declare function cache(options?: CacheOptions): CacheMiddleware;

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli.js

@@ -1,302 +0,0 @@
-#!/usr/bin/env node
-
-// cli.ts
-import { mkdir, writeFile, copyFile, readFile, cp } from "node:fs/promises";
-import { existsSync, readdirSync } from "node:fs";
-import { execSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join, dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname(__filename);
-var pkgRoot = existsSync(join(__dirname, "package.json")) ? __dirname : resolve(__dirname, "..");
-async function readPkg() {
-  return JSON.parse(await readFile(join(pkgRoot, "package.json"), "utf-8"));
-}
-async function cmdSkill() {
-  const targetDir = join(homedir(), ".agents", "skills", "weifuwu");
-  await mkdir(targetDir, { recursive: true });
-  await copyFile(join(pkgRoot, "README.md"), join(targetDir, "SKILL.md"));
-  console.log("\u2705 Installed weifuwu skill to ~/.agents/skills/weifuwu/");
-}
-async function cmdVersion() {
-  const pkg = await readPkg();
-  console.log(pkg.version);
-}
-async function cmdInit(name, opts) {
-  const targetDir = resolve(process.cwd(), name);
-  const pkg = await readPkg();
-  const v = pkg.version;
-  const typeVersions = {
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "@types/node": "^22"
-  };
-  const depVer = (depName) => typeVersions[depName] || `^${(pkg.devDependencies?.[depName] || "0.0.0").replace(/^\^/, "")}`;
-  await mkdir(targetDir, { recursive: true });
-  const templateDir = join(pkgRoot, "cli", "template");
-  await cp(templateDir, targetDir, { recursive: true });
-  for (const file of ["app.ts", "index.ts"]) {
-    const fp = join(targetDir, file);
-    let content = await readFile(fp, "utf-8");
-    content = content.replace(/from '\.\.\/\.\.\/index\.ts'/g, "from 'weifuwu'").replace(/from '\.\.\/\.\.\/\.\.\/react\.ts'/g, "from 'weifuwu/react'");
-    await writeFile(fp, content);
-  }
-  const uiPage = join(targetDir, "ui", "app", "page.tsx");
-  if (existsSync(uiPage)) {
-    let content = await readFile(uiPage, "utf-8");
-    content = content.replace(/from '\.\.\/\.\.\/\.\.\/\.\.\/react\.ts'/g, "from 'weifuwu/react'");
-    await writeFile(uiPage, content);
-  }
-  if (opts.minimal) {
-    try {
-      await rmrf(join(targetDir, "ui"));
-    } catch {
-    }
-    try {
-      await rmrf(join(targetDir, "locales"));
-    } catch {
-    }
-    await writeFile(
-      join(targetDir, "app.ts"),
-      [
-        `import { Router } from 'weifuwu'`,
-        ``,
-        `export const app = new Router()`,
-        ``,
-        `app.get('/', () => new Response('Hello from ${name}!'))`,
-        `app.get('/api/ping', () => Response.json({ pong: true, time: new Date().toISOString() }))`,
-        ``
-      ].join("\n")
-    );
-    await writeFile(
-      join(targetDir, "index.ts"),
-      [
-        `import { serve } from 'weifuwu'`,
-        `import { app } from './app.ts'`,
-        ``,
-        `const port = Number(process.env.PORT) || 3000`,
-        `serve(app.handler(), { port })`,
-        ``
-      ].join("\n")
-    );
-  }
-  const deps = { weifuwu: `^${v}` };
-  const devDeps = {};
-  if (!opts.minimal) {
-    deps["react"] = "^19";
-    deps["react-dom"] = "^19";
-    deps["tailwindcss"] = "^4";
-    devDeps["@types/react"] = depVer("@types/react");
-    devDeps["@types/react-dom"] = depVer("@types/react-dom");
-  }
-  devDeps["@types/node"] = depVer("@types/node");
-  await writeFile(
-    join(targetDir, "package.json"),
-    JSON.stringify(
-      {
-        name,
-        type: "module",
-        scripts: {
-          dev: "NODE_ENV=development node --watch index.ts",
-          start: "node index.ts"
-        },
-        dependencies: deps,
-        devDependencies: devDeps
-      },
-      null,
-      2
-    ) + "\n"
-  );
-  const include = opts.minimal ? ["*.ts"] : ["*.ts", "ui/**/*.ts", "ui/**/*.tsx"];
-  await writeFile(
-    join(targetDir, "tsconfig.json"),
-    JSON.stringify(
-      {
-        compilerOptions: {
-          target: "ESNext",
-          module: "NodeNext",
-          moduleResolution: "NodeNext",
-          strict: true,
-          jsx: "react-jsx",
-          skipLibCheck: true,
-          noEmit: true,
-          allowImportingTsExtensions: true
-        },
-        include
-      },
-      null,
-      2
-    ) + "\n"
-  );
-  await writeFile(join(targetDir, ".gitignore"), "node_modules\ndist\n.env\n.sessions\n.weifuwu\n");
-  await writeFile(join(targetDir, ".env"), "PORT=3000\n");
-  await writeFile(
-    join(targetDir, "AGENTS.md"),
-    [
-      `# ${name}`,
-      "",
-      `This is a [weifuwu](https://weifuwu.io) application \u2014 pure Node.js, no build step.`,
-      "",
-      "## Commands",
-      "",
-      "- `npm run dev` \u2014 start dev server with hot reload",
-      "- `npm start` \u2014 start production server",
-      "- `npm install` \u2014 install dependencies",
-      "- `npx tsc --noEmit` \u2014 type-check",
-      "",
-      "## API Reference",
-      "",
-      "See `node_modules/weifuwu/README.md` for the full documentation.",
-      ""
-    ].join("\n")
-  );
-  if (!opts.skipInstall) {
-    console.log("\nInstalling dependencies...");
-    execSync("npm install", { cwd: targetDir, stdio: "inherit" });
-  }
-  console.log(
-    `
-\u2705 Created ${name}/ \u2014 cd ${name} && ${opts.skipInstall ? "npm install && " : ""}npm run dev`
-  );
-}
-async function cmdDev() {
-  const entry = existsSync("index.ts") ? "index.ts" : existsSync("app.ts") ? "app.ts" : null;
-  if (!entry) {
-    console.error("No index.ts or app.ts found in current directory.");
-    console.error("Run `npx weifuwu init <name>` to create a new project.");
-    process.exit(1);
-  }
-  console.log(`Starting dev server (${entry})...`);
-  execSync(`NODE_ENV=development node --watch ${entry}`, { stdio: "inherit" });
-}
-async function cmdGenerate(type, name) {
-  if (type !== "module") {
-    console.error(`Unknown generate type: ${type}. Usage: npx weifuwu generate module <name>`);
-    process.exit(1);
-  }
-  const dir = join(process.cwd(), name);
-  if (existsSync(dir)) {
-    console.error(`Directory ${name} already exists.`);
-    process.exit(1);
-  }
-  await mkdir(dir, { recursive: true });
-  await writeFile(
-    join(dir, "index.ts"),
-    [
-      `import type { Middleware } from 'weifuwu'`,
-      ``,
-      `export interface ${capitalize(name)}Options {`,
-      `  // Add your options here`,
-      `}`,
-      ``,
-      `export function ${name}(opts?: ${capitalize(name)}Options): Middleware {`,
-      `  return async (req, ctx, next) => {`,
-      `    // Your middleware logic here`,
-      `    return next(req, ctx)`,
-      `  }`,
-      `}`,
-      ``
-    ].join("\n")
-  );
-  await mkdir(join(dir, "..", "test"), { recursive: true });
-  await writeFile(
-    join(dir, "..", "test", `${name}.test.ts`),
-    [
-      `import { describe, it } from 'node:test'`,
-      `import assert from 'node:assert/strict'`,
-      `import { ${name} } from '../${name}/index.ts'`,
-      `import { Router } from 'weifuwu'`,
-      ``,
-      `describe('${name}', () => {`,
-      `  it('works as middleware', async () => {`,
-      `    const app = new Router()`,
-      `    app.use(${name}())`,
-      `    app.get('/', () => new Response('ok'))`,
-      ``,
-      `    const res = await app.handler()(`,
-      `      new Request('http://localhost/'),`,
-      `      { params: {}, query: {} } as any,`,
-      `    )`,
-      `    assert.equal(res.status, 200)`,
-      `  })`,
-      `})`,
-      ``
-    ].join("\n")
-  );
-  console.log(`\u2705 Created module ${name}/ with index.ts and test/${name}.test.ts`);
-}
-function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-async function rmrf(dir) {
-  try {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const p = join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await rmrf(p);
-      } else {
-        const { unlink } = await import("node:fs/promises");
-        await unlink(p);
-      }
-    }
-    const { rmdir } = await import("node:fs/promises");
-    await rmdir(dir);
-  } catch {
-  }
-}
-var cmd = process.argv[2];
-var HELP = `
-weifuwu \u2014 Web-standard HTTP framework for Node.js
-
-Usage:
-  npx weifuwu init <name>              Create a new project (SSR + i18n + theme)
-  npx weifuwu init <name> --minimal    Create a minimal HTTP project
-  npx weifuwu init <name> --skip-install  Create project, skip npm install
-  npx weifuwu dev                       Start dev server in current directory
-  npx weifuwu generate module <name>    Scaffold a new module
-  npx weifuwu version                   Print version
-`;
-if (cmd === "version" || cmd === "-v" || cmd === "--version") {
-  cmdVersion().catch(console.error);
-} else if (cmd === "skill") {
-  cmdSkill().catch(console.error);
-} else if (cmd === "init") {
-  const { values, positionals } = parseArgs({
-    args: process.argv.slice(3),
-    options: {
-      minimal: { type: "boolean", short: "m" },
-      "skip-install": { type: "boolean" }
-    },
-    strict: false,
-    allowPositionals: true
-  });
-  const name = positionals[0];
-  if (!name) {
-    console.error("Usage: npx weifuwu init <name> [--minimal] [--skip-install]");
-    process.exit(1);
-  }
-  cmdInit(name, { minimal: !!values.minimal, skipInstall: !!values["skip-install"] }).catch(
-    console.error
-  );
-} else if (cmd === "dev") {
-  cmdDev();
-} else if (cmd === "generate" || cmd === "g") {
-  const { positionals } = parseArgs({
-    args: process.argv.slice(3),
-    options: {},
-    strict: false,
-    allowPositionals: true
-  });
-  const type = positionals[0];
-  const name = positionals[1];
-  if (!type || !name) {
-    console.error("Usage: npx weifuwu generate module <name>");
-    process.exit(1);
-  }
-  cmdGenerate(type, name).catch(console.error);
-} else {
-  console.log(HELP);
-}

package/dist/client-locale.d.ts

@@ -1,25 +0,0 @@
-/**
- * React hook to read and change the locale on the client side.
- *
- * Changes are made via SPA navigation to `/__lang/{locale}`, which is
- * intercepted by the client router and applied without a full page reload.
- *
- * ```tsx
- * import { useLocale } from 'weifuwu/react'
- *
- * function LangSwitcher() {
- *   const { locale, setLocale, t } = useLocale()
- *   return (
- *     <>
- *       <p>{t('greeting')}</p>
- *       <button onClick={() => setLocale('zh')}>中文</button>
- *     </>
- *   )
- * }
- * ```
- */
-export declare function useLocale(): {
-    locale: string | undefined;
-    setLocale: (locale: string) => Promise<void>;
-    t: (key: string, params?: Record<string, string>, fallback?: string) => string;
-};

package/dist/client-pref.d.ts

@@ -1,3 +0,0 @@
-export type UrlInterceptor = (url: URL) => boolean | Promise<boolean>;
-export declare function addInterceptor(fn: UrlInterceptor): void;
-export declare function runInterceptors(url: URL): Promise<boolean>;