npm - weifuwu - Versions diffs - 0.31.1 → 0.32.0 - Mend

weifuwu 0.31.1 → 0.32.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

package/README.md +238 -120
package/dist/ai/agent.d.ts +127 -0
package/dist/ai/index.d.ts +26 -0
package/dist/ai/types.d.ts +59 -0
package/dist/core/router.d.ts +11 -0
package/dist/index.d.ts +16 -7
package/dist/index.js +1186 -315
package/dist/middleware/auth.d.ts +68 -0
package/dist/middleware/esbuild-dev.d.ts +69 -0
package/dist/middleware/esbuild-dev.js +335 -0
package/dist/middleware/sandbox.d.ts +52 -0
package/dist/middleware/tailwind-dev.d.ts +43 -0
package/dist/middleware/tailwind-dev.js +199 -0
package/dist/react/client.d.ts +64 -27
package/dist/react/client.js +130 -248
package/dist/react/compile.d.ts +17 -0
package/dist/react/error-boundary.d.ts +18 -19
package/dist/react/index.d.ts +80 -16
package/dist/react/index.js +835 -267
package/dist/react/types.d.ts +134 -34
package/dist/types.d.ts +7 -0
package/package.json +17 -6
package/dist/react/navigation.d.ts +0 -63
package/dist/react/navigation.js +0 -154
package/dist/react/render.d.ts +0 -8
package/dist/react/route-utils.d.ts +0 -31

package/dist/middleware/tailwind-dev.js ADDED Viewed

@@ -0,0 +1,199 @@
+// src/middleware/tailwind-dev.ts
+import { resolve } from "node:path";
+import { stat, readFile, glob } from "node:fs/promises";
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function defaultErrorTemplate(errors) {
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Tailwind Build Error</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: system-ui; background: #1a1a2e; color: #e0e0e0; padding: 2rem; }
+    .overlay { position: fixed; inset: 0; display: flex; align-items: center; justify-content: center; }
+    .card { background: #16213e; border: 1px solid #06b6d4; border-radius: 12px; padding: 2rem; max-width: 800px; width: 100%; box-shadow: 0 8px 32px rgba(0,0,0,0.4); }
+    h1 { color: #06b6d4; font-size: 1.5rem; margin-bottom: 1rem; display: flex; align-items: center; gap: 0.5rem; }
+    pre { background: #0f0f23; padding: 1.5rem; border-radius: 8px; overflow: auto; font-size: 0.85rem; line-height: 1.6; white-space: pre-wrap; word-break: break-word; }
+  </style>
+</head>
+<body>
+  <div class="overlay">
+    <div class="card">
+      <h1>\u{1F3A8} Tailwind CSS Build Error</h1>
+      <pre>${escapeHtml(errors)}</pre>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+var TW_CANDIDATE_RE = /[a-z][\w-]*(?::[a-z][\w-]*)*(?:-\[[^\]]*\])*(?:\/[0-9]+)?/gi;
+var CLASS_CONTEXT_RE = /(?:class(?:Name)?\s*[=:]\s*["'`]([^"'`]+)["'`]|["'`]([^"'`\n]{2,})["'`])/g;
+async function extractCandidates(patterns, root) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const resolved = resolve(root, pattern);
+    try {
+      for await (const file of glob(resolved)) {
+        try {
+          const content = await readFile(file, "utf-8");
+          for (const m of content.matchAll(CLASS_CONTEXT_RE)) {
+            const str = m[1] ?? m[2];
+            if (!str) continue;
+            for (const c of str.matchAll(TW_CANDIDATE_RE)) {
+              seen.add(c[0]);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  return [...seen];
+}
+async function collectFileMtimes(files) {
+  const map = /* @__PURE__ */ new Map();
+  await Promise.all(
+    files.map(async (f) => {
+      try {
+        const s = await stat(f);
+        map.set(f, s.mtimeMs);
+      } catch {
+      }
+    })
+  );
+  return map;
+}
+function isCacheValid(cached) {
+  return Promise.all(
+    [...cached.files].map(async ([file, mtime]) => {
+      try {
+        const s = await stat(file);
+        return s.mtimeMs === mtime;
+      } catch {
+        return false;
+      }
+    })
+  ).then((results) => results.every(Boolean));
+}
+function tailwindDev(opts) {
+  const cacheMode = opts.cache ?? "memory";
+  const errorTemplate = opts.errorTemplate ?? defaultErrorTemplate;
+  const entries = Object.entries(opts.entries).map(([p, e]) => {
+    const path = p.startsWith("/") ? p : "/" + p;
+    const config = typeof e === "string" ? { entry: e } : e;
+    return { path, config };
+  });
+  const cacheStore = /* @__PURE__ */ new Map();
+  let compileFn = null;
+  let loadError = null;
+  async function getCompile() {
+    if (compileFn) return compileFn;
+    try {
+      const mod = await import("@tailwindcss/node");
+      compileFn = mod.compile;
+      return compileFn;
+    } catch (err) {
+      loadError = `@tailwindcss/node is not installed. Run: npm install -D tailwindcss @tailwindcss/node
+${String(err)}`;
+      throw new Error(loadError, { cause: err });
+    }
+  }
+  async function compileCss(entry) {
+    const compile = await getCompile();
+    const entryAbs = resolve(entry.entry);
+    const cssSource = await readFile(entryAbs, "utf-8");
+    const baseDir = resolve(entry.entry, "..");
+    const deps = [entryAbs];
+    const result = await compile(cssSource, {
+      base: baseDir,
+      onDependency: (p) => {
+        if (!deps.includes(p)) deps.push(p);
+      }
+    });
+    const contentPatterns = entry.content ?? [];
+    for (const src of result.sources) {
+      if (!src.negated) {
+        contentPatterns.push(resolve(src.base, src.pattern));
+      }
+    }
+    let candidates = [];
+    if (contentPatterns.length > 0) {
+      candidates = await extractCandidates(contentPatterns, baseDir);
+    }
+    const css = result.build(candidates);
+    for (const pattern of contentPatterns) {
+      try {
+        for await (const file of glob(resolve(baseDir, pattern))) {
+          if (!deps.includes(file)) deps.push(file);
+        }
+      } catch {
+      }
+    }
+    const etag = `"tw-${hashCode(css)}"`;
+    return { css, etag, files: deps };
+  }
+  return async (req, ctx, next) => {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const matched = entries.find((e) => e.path === pathname);
+    if (!matched) return next(req, ctx);
+    const { config } = matched;
+    try {
+      if (cacheMode === "memory") {
+        const cached = cacheStore.get(pathname);
+        if (cached) {
+          const valid = await isCacheValid(cached);
+          if (valid) {
+            if (req.headers.get("if-none-match") === cached.etag) {
+              return new Response(null, { status: 304 });
+            }
+            return new Response(cached.css, {
+              headers: {
+                "Content-Type": "text/css; charset=utf-8",
+                ETag: cached.etag,
+                "Cache-Control": "no-cache"
+              }
+            });
+          }
+          cacheStore.delete(pathname);
+        }
+      }
+      const { css, etag, files } = await compileCss(config);
+      if (cacheMode === "memory") {
+        const mtimes = await collectFileMtimes(files);
+        cacheStore.set(pathname, { css, etag, files: mtimes });
+      }
+      return new Response(css, {
+        headers: {
+          "Content-Type": "text/css; charset=utf-8",
+          ETag: etag,
+          "Cache-Control": "no-cache"
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const html = errorTemplate(message);
+      return new Response(html, {
+        status: 500,
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+  };
+}
+function hashCode(s) {
+  let hash = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s.charCodeAt(i);
+    hash = (hash << 5) - hash + ch;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36);
+}
+export {
+  tailwindDev
+};

package/dist/react/client.d.ts CHANGED Viewed

@@ -1,39 +1,76 @@
 /**
- * Client-side entry for React hydration + SPA navigation.
+ * Client-side entry for React hydration and SPA routing.
  *
- * Usage (in a client bundle):
+ * Hydration:
  * ```ts
- * import { hydrate, createClientRouter } from 'weifuwu/react/client'
- * import HomePage from './pages/HomePage.js'
+ * import { hydrate } from 'weifuwu/react/client'
+ * hydrate(HomePage, { layout: PageShell })
+ * ```
  *
- * const router = createClientRouter([
- *   { path: '/', component: HomePage },
- *   { path: '/users/:id', component: UserPage, loader: ... },
- * ])
- * hydrate(router.App)
+ * Client-side router:
+ * ```ts
+ * import { createBrowserRouter } from 'weifuwu/react/client'
+ * createBrowserRouter({
+ *   layout: PageShell,
+ *   routes: {
+ *     '/': () => import('./pages/HomePage.tsx'),
+ *     '/users/:id': () => import('./pages/UserPage.tsx'),
+ *   },
+ * })
  * ```
  */
-import { type ComponentType, type ReactElement } from 'react';
-import { type LinkProps } from './navigation.ts';
+import { type ComponentType, type ReactNode } from 'react';
 export interface HydrateOptions {
+    /** Hydration target element. Default: document.getElementById('root'). */
     container?: HTMLElement;
+    /**
+     * Layout component matching the server-side `react({ layout })` config.
+     * Must accept `{ children: ReactNode }`.
+     * When provided, wraps the page component before hydrating —
+     * producing the same tree the server rendered.
+     */
+    layout?: ComponentType<{
+        children: ReactNode;
+    }>;
 }
-export interface ClientRoute {
-    path: string;
-    component: ComponentType;
-    loader?: (params: Record<string, string>) => Promise<Record<string, unknown>>;
+/**
+ * Hydrate a page component. When `layout` is provided, the hydration tree
+ * matches the server-rendered structure: `<div id="root"><Layout><App /></Layout></div>`.
+ */
+export declare function hydrate(App: ComponentType, opts?: HydrateOptions): void;
+export interface ClientRouterOptions {
+    /** Layout component shared across all routes. */
+    layout?: ComponentType<{
+        children: ReactNode;
+    }>;
+    /**
+     * Route map: URL pattern → lazy component loader.
+     * Patterns support `:param` segments (e.g. `/users/:id`).
+     */
+    routes: Record<string, () => Promise<Record<string, unknown>>>;
+    /**
+     * Fallback component for unmatched routes.
+     * When omitted, unmatched routes do a full page navigation.
+     */
+    fallback?: () => Promise<Record<string, unknown>>;
+    /** Target element. Default: document.getElementById('root'). */
+    container?: HTMLElement;
 }
-export interface ClientRouter {
-    App: ComponentType;
-    Link: (props: LinkProps) => ReactElement;
-    useParams: () => Record<string, string>;
-    navigate: (url: string) => Promise<void>;
+interface RouterHandle {
+    navigate(url: string): Promise<void>;
+    renderPath(pathname: string, isInitial: boolean, data?: Record<string, unknown>): Promise<void>;
 }
-export { Link, useParams, useNavigate, useRevalidate, Form, useNavigation } from './navigation.ts';
-export type { LinkProps, FormProps, NavigationState } from './navigation.ts';
-export { ErrorBoundary } from './error-boundary.ts';
-export type { ErrorBoundaryProps } from './error-boundary.ts';
-export { defineRoute } from './route-utils.ts';
-export declare function createClientRouter(routes: ClientRoute[]): ClientRouter;
-export declare function hydrate(App: ComponentType, opts?: HydrateOptions): void;
+/**
+ * Initialise the client-side router.
+ *
+ * On the initial page load, it hydrates the matching route from the
+ * server-rendered HTML.  Subsequent in-app navigations fetch fresh
+ * server data and render the new page client-side.
+ */
+export declare function createBrowserRouter(opts: ClientRouterOptions): RouterHandle;
+/**
+ * Programmatic navigation (call from anywhere).
+ * Falls back to `window.location.href = url` if the router hasn't been initialised.
+ */
+export declare function navigate(url: string): void;
 export { useServerData } from './hooks.ts';