@mauroandre/velojs 0.0.4 → 0.0.6

package/dist/hooks.js

@@ -0,0 +1,72 @@
+import { signal as f, useSignal as _ } from "@preact/signals";
+import { useEffect as v } from "preact/hooks";
+import { useLocation as d, useParams as w } from "wouter-preact";
+function p(e) {
+  e.value !== null && typeof e.value == "object" && (e.value = { ...e.value });
+}
+function y(e) {
+  const t = f(!1);
+  if (typeof window > "u")
+    return { data: {
+      get value() {
+        return e ? globalThis.__veloServerData?.getStore?.()?.[e] ?? null : null;
+      }
+    }, loading: t };
+  const a = window.__PAGE_DATA__, r = e && a?.[e] ? a[e] : null;
+  return { data: f(r), loading: t };
+}
+function S(e, t) {
+  let a, r;
+  Array.isArray(e) ? r = e : (a = e, r = t);
+  let n = null;
+  if (typeof window > "u" && a) {
+    const i = globalThis.__veloServerData?.getStore?.();
+    i?.[a] && (n = i[a]);
+  }
+  if (typeof window < "u" && a) {
+    const o = window.__PAGE_DATA__;
+    o?.[a] && (n = o[a], delete o[a]);
+  }
+  const c = _(n), s = _(!1), l = () => {
+    if (typeof window > "u" || !a) return;
+    const o = window.location.pathname, i = new URLSearchParams(window.location.search);
+    i.set("_data", "1"), s.value = !0, fetch(`${o}?${i.toString()}`).then((u) => u.json()).then((u) => {
+      c.value = u[a], s.value = !1;
+    }).catch((u) => {
+      console.error("Erro ao carregar dados:", u), s.value = !1;
+    });
+  };
+  return v(() => {
+    n === null && l();
+  }, r ?? []), { data: c, loading: s, refetch: l };
+}
+function m() {
+  const [, e] = d();
+  return e;
+}
+function P() {
+  return typeof window > "u" ? globalThis.__veloServerData?.getStore?.()?.__params ?? {} : w();
+}
+function A() {
+  if (typeof window > "u")
+    return globalThis.__veloServerData?.getStore?.()?.__query ?? {};
+  const e = window.__PAGE_DATA__;
+  if (e?.__query)
+    return e.__query;
+  const t = new URLSearchParams(window.location.search), a = {};
+  return t.forEach((r, n) => {
+    a[n] = r;
+  }), a;
+}
+function T() {
+  return typeof window > "u" ? globalThis.__veloServerData?.getStore?.()?.__pathname ?? "/" : (d(), window.location.pathname);
+}
+export {
+  y as Loader,
+  p as touch,
+  S as useLoader,
+  m as useNavigate,
+  P as useParams,
+  T as usePathname,
+  A as useQuery
+};

package/{src/index.ts → dist/index.d.ts}

@@ -1,19 +1,5 @@
-// Types
-export type {
-    AppRoutes,
-    RouteNode,
-    RouteModule,
-    LoaderArgs,
-    ActionArgs,
-    Metadata,
-} from "./types.js";
-
-// Config
+export type { AppRoutes, RouteNode, RouteModule, LoaderArgs, ActionArgs, Metadata, } from "./types.js";
 export type { VeloConfig } from "./config.js";
 export { defineConfig } from "./config.js";
-
-// Components
 export { Scripts, Link } from "./components.js";
-
-// Re-export Hono types
 export type { Context, MiddlewareHandler, Next } from "hono";

package/dist/index.js

@@ -0,0 +1,7 @@
+import { defineConfig as e } from "./config.js";
+import { Link as i, Scripts as n } from "./components.js";
+export {
+  i as Link,
+  n as Scripts,
+  e as defineConfig
+};

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function runInit(dirName?: string): Promise<void>;

package/dist/init.js

@@ -0,0 +1,149 @@
+import t from "node:fs";
+import s from "node:path";
+import { fileURLToPath as d } from "node:url";
+const i = "@mauroandre/velojs";
+function m() {
+  const o = s.dirname(d(import.meta.url)), e = s.resolve(o, "../package.json");
+  return JSON.parse(t.readFileSync(e, "utf-8")).version;
+}
+const u = {
+  "package.json": `{
+    "name": "my-velojs-app",
+    "version": "0.1.0",
+    "type": "module",
+    "scripts": {
+        "dev": "velojs dev",
+        "build": "velojs build",
+        "start": "velojs start"
+    },
+    "dependencies": {
+        "${i}": "^${m()}"
+    },
+    "devDependencies": {
+        "@types/node": "latest",
+        "typescript": "latest"
+    }
+}
+`,
+  "vite.config.ts": `import { veloPlugin } from "${i}/vite";
+
+export default { plugins: [veloPlugin()] };
+`,
+  "tsconfig.json": `{
+    "compilerOptions": {
+        "module": "esnext",
+        "moduleResolution": "bundler",
+        "target": "esnext",
+        "lib": ["esnext", "dom"],
+        "types": ["node", "vite/client"],
+        "strict": true,
+        "noUncheckedIndexedAccess": true,
+        "verbatimModuleSyntax": true,
+        "isolatedModules": true,
+        "skipLibCheck": true,
+        "esModuleInterop": true,
+        "noEmit": true,
+        "jsx": "react-jsx",
+        "jsxImportSource": "preact"
+    },
+    "include": ["app/**/*"],
+    "exclude": ["node_modules", "dist"]
+}
+`,
+  "app/routes.tsx": `import type { AppRoutes } from "${i}";
+
+import * as Root from "./client-root.js";
+import * as Home from "./pages/Home.js";
+
+export default [
+    {
+        module: Root,
+        isRoot: true,
+        children: [
+            { path: "/", module: Home },
+        ],
+    },
+] satisfies AppRoutes;
+`,
+  "app/server.tsx": `// Server initialization
+// Use this file to set up server-side logic:
+//   import { addRoutes, onServer } from "${i}/server";
+`,
+  "app/client.tsx": `import "./styles/global.css";
+`,
+  "app/client-root.tsx": `import { Scripts } from "${i}";
+
+interface RootProps {
+    children: preact.ComponentChildren;
+}
+
+export const Component = ({ children }: RootProps) => {
+    return (
+        <html lang="en">
+            <head>
+                <meta charSet="utf-8" />
+                <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+                <title>VeloJS App</title>
+                <Scripts />
+            </head>
+            <body>{children}</body>
+        </html>
+    );
+};
+`,
+  "app/styles/global.css": `*,
+*::before,
+*::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: system-ui, -apple-system, sans-serif;
+    line-height: 1.6;
+    color: #1a1a1a;
+    background: #fafafa;
+}
+
+a {
+    color: #0066cc;
+    text-decoration: none;
+}
+
+a:hover {
+    text-decoration: underline;
+}
+`,
+  "app/pages/Home.tsx": `export const Component = () => {
+    return (
+        <main style={{ maxWidth: 640, margin: "80px auto", padding: "0 20px" }}>
+            <h1>Welcome to VeloJS</h1>
+            <p>Edit <code>app/pages/Home.tsx</code> to get started.</p>
+        </main>
+    );
+};
+`
+};
+async function v(o) {
+  const e = o ? s.resolve(process.cwd(), o) : process.cwd(), r = s.basename(e);
+  t.existsSync(e) ? t.readdirSync(e).filter(
+    (n) => !n.startsWith(".") && n !== "node_modules"
+  ).length > 0 && (console.error(
+    `Error: Directory "${r}" is not empty. Use an empty directory.`
+  ), process.exit(1)) : t.mkdirSync(e, { recursive: !0 });
+  for (const [a, n] of Object.entries(u)) {
+    const c = s.join(e, a), l = s.dirname(c);
+    t.existsSync(l) || t.mkdirSync(l, { recursive: !0 });
+    const p = a === "package.json" ? n.replace("my-velojs-app", r) : n;
+    t.writeFileSync(c, p);
+  }
+  console.log(`
+Project created in ${o ? r : "current directory"}!
+`), console.log(`Next steps:
+`), o && console.log(`  cd ${r}`), console.log("  npm install"), console.log(`  npx velojs dev
+`);
+}
+export {
+  v as runInit
+};

package/dist/server.d.ts

@@ -0,0 +1,14 @@
+import { Hono } from "hono";
+import type { AppRoutes } from "./types.js";
+import { AsyncLocalStorage } from "node:async_hooks";
+export declare const serverDataStorage: AsyncLocalStorage<Record<string, unknown>>;
+type ServerCallback = (server: import("http").Server) => void;
+export declare function onServer(fn: ServerCallback): void;
+export interface StartServerOptions {
+    routes: AppRoutes;
+    port?: number;
+}
+export declare function addRoutes(fn: (app: Hono) => void | Promise<void>): void;
+export declare const createApp: (routes: AppRoutes) => Promise<Hono>;
+export declare const startServer: (options: StartServerOptions) => Promise<Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">>;
+export default createApp;

package/dist/server.js

@@ -0,0 +1,168 @@
+import { jsx as h } from "preact/jsx-runtime";
+import { Hono as T } from "hono";
+import { logger as A } from "hono/logger";
+import { trimTrailingSlash as R } from "hono/trailing-slash";
+import { render as D } from "preact-render-to-string";
+import { Router as N } from "wouter-preact";
+import { AsyncLocalStorage as O } from "node:async_hooks";
+const v = new O();
+globalThis.__veloServerData = v;
+const g = [];
+let p = null;
+function x(t) {
+  if (p) {
+    t(p);
+    return;
+  }
+  g.push(t);
+}
+function y(t) {
+  p = t;
+  for (const e of g) e(t);
+  g.length = 0;
+}
+const w = [];
+function B(t) {
+  w.push(t);
+}
+const b = (t, e, o) => {
+  if (t.req.query("_data") === "1")
+    return t.json(o ?? null);
+  const s = t.req.path, r = v.run(
+    o ?? {},
+    () => D(/* @__PURE__ */ h(N, { ssrPath: s, children: e }))
+  );
+  if (!o)
+    return t.html(r);
+  const a = `<script>window.__PAGE_DATA__=${JSON.stringify(
+    o
+  )}<\/script>`;
+  return t.html(r.replace("</head>", `${a}</head>`));
+}, j = async (t, e) => {
+  const o = e.req.param(), s = e.req.query(), r = { params: o, query: s, c: e }, a = await Promise.all(
+    t.map(async (n) => {
+      if (!n.loader) return null;
+      const u = await n.loader(r), i = n.metadata?.moduleId;
+      return i ? { moduleId: i, loaderData: u } : null;
+    })
+  ), c = {
+    __params: o,
+    __query: s,
+    __pathname: e.req.path
+  };
+  for (const n of a)
+    n && (c[n.moduleId] = n.loaderData);
+  return {
+    components: t.map((n) => n.Component),
+    data: c
+  };
+}, I = (t) => {
+  if (t.length === 0) return null;
+  const e = t.filter(Boolean);
+  if (e.length === 0) return null;
+  if (e.length === 1) {
+    const r = e[0];
+    return /* @__PURE__ */ h(r, {});
+  }
+  const o = e[e.length - 1];
+  return e.slice(0, -1).reduceRight((r, a) => /* @__PURE__ */ h(a, { children: r }), /* @__PURE__ */ h(o, {}));
+}, S = (t, e, o = [], s = []) => {
+  for (const r of e) {
+    const a = [...o, r.module], c = [
+      ...s,
+      ...r.middlewares || []
+    ];
+    if (r.children)
+      S(
+        t,
+        r.children,
+        a,
+        c
+      );
+    else {
+      const n = r.module.metadata?.fullPath;
+      if (!n) {
+        console.warn(
+          `Module ${r.module.metadata?.moduleId} has no fullPath`
+        );
+        continue;
+      }
+      const u = async (i) => {
+        const { components: d, data: f } = await j(a, i), l = I(d);
+        return b(i, l, f);
+      };
+      c.length > 0 ? t.on(["GET"], [n], ...c, u) : t.on(["GET"], [n], u);
+    }
+  }
+}, P = (t, e, o = []) => {
+  for (const s of e) {
+    const r = s.module.metadata?.moduleId, a = [
+      ...o,
+      ...s.middlewares || []
+    ];
+    if (r) {
+      const c = Object.keys(s.module).filter(
+        (n) => n.startsWith("action_")
+      );
+      for (const n of c) {
+        const u = n.replace("action_", ""), i = s.module[n];
+        if (typeof i == "function") {
+          const d = `/_action/${r}/${u}`, f = async (l) => {
+            let _ = {};
+            try {
+              _ = await l.req.json();
+            } catch {
+            }
+            const q = {
+              body: _,
+              params: l.req.param(),
+              query: l.req.query(),
+              c: l
+            };
+            try {
+              const m = await i(q);
+              return l.json(m ?? { ok: !0 });
+            } catch (m) {
+              const E = m instanceof Error ? m.message : "Action failed";
+              return l.json({ error: E }, 500);
+            }
+          };
+          a.length > 0 ? t.on(
+            ["POST"],
+            [d],
+            ...a,
+            f
+          ) : t.on(["POST"], [d], f);
+        }
+      }
+    }
+    s.children && P(t, s.children, a);
+  }
+}, C = async (t) => {
+  const e = new T();
+  e.use(R()), process.env.NODE_ENV !== "production" && e.use("*", A());
+  for (const o of w)
+    await o(e);
+  if (S(e, t), P(e, t), process.env.NODE_ENV !== "production" && !p) {
+    const o = globalThis.__veloDevServer;
+    o && y(o);
+  }
+  return e;
+}, K = async (t) => {
+  const { routes: e, port: o = Number(process.env.SERVER_PORT) || 3e3 } = t, s = await C(e);
+  if (process.env.NODE_ENV === "production") {
+    const { serve: r } = await import("@hono/node-server"), { serveStatic: a } = await import("@hono/node-server/serve-static"), { dirname: c, join: n } = await import("node:path"), { fileURLToPath: u } = await import("node:url"), i = c(u(import.meta.url)), d = n(i, "client");
+    (process.env.STATIC_BASE_URL || "").startsWith("http") || s.use("/*", a({ root: d })), console.log(`Server running on http://localhost:${o}`);
+    const l = r({ fetch: s.fetch, port: o });
+    y(l);
+  }
+  return s;
+};
+export {
+  B as addRoutes,
+  C as createApp,
+  C as default,
+  x as onServer,
+  v as serverDataStorage,
+  K as startServer
+};

package/{src/types.ts → dist/types.d.ts}

@@ -1,33 +1,28 @@
 import type { ComponentType } from "preact";
 import type { Context, MiddlewareHandler } from "hono";
-
 export interface LoaderArgs {
     params: Record<string, string>;
     query: Record<string, string>;
     c: Context;
 }
-
 export interface ActionArgs<TBody = unknown> {
     body: TBody;
     params?: Record<string, string>;
     query?: Record<string, string>;
     c?: Context;
 }
-
 export interface Metadata {
     moduleId: string;
     fullPath?: string;
     path?: string;
     [key: string]: unknown;
 }
-
 export interface RouteModule {
     Component: ComponentType<any>;
     loader?: (args: LoaderArgs) => Promise<any>;
     metadata?: Metadata;
     [key: `action_${string}`]: (args: ActionArgs<any>) => Promise<any>;
 }
-
 export interface RouteNode {
     path?: string;
     module: RouteModule;
@@ -35,5 +30,4 @@ export interface RouteNode {
     middlewares?: MiddlewareHandler[];
     isRoot?: boolean;
 }
-
 export type AppRoutes = RouteNode[];

package/dist/types.js

@@ -0,0 +1 @@
+

package/dist/vite.d.ts

@@ -0,0 +1,22 @@
+import type { PluginOption } from "vite";
+import type { VeloConfig } from "./config.js";
+import * as t from "@babel/types";
+export declare function injectMetadata(code: string, moduleId: string, fullPath?: string, path?: string): string;
+export declare function transformLoaderFunctions(code: string, moduleId: string): string;
+export declare function transformActionsForClient(code: string, moduleId: string): string;
+export declare function removeLoaders(code: string): string;
+export declare function removeMiddlewares(code: string): string;
+export interface PathInfo {
+    fullPath: string;
+    path: string;
+}
+/**
+ * Parseia routes.tsx e retorna Map de moduleId → { fullPath, path }
+ * moduleId aqui é derivado do import source (ex: "./auth/Login.js" → "auth/Login")
+ */
+export declare function buildFullPathMap(code: string): Map<string, PathInfo>;
+/**
+ * Percorre recursivamente a árvore de rotas e coleta moduleName → { fullPath, path }
+ */
+export declare function collectFullPaths(elements: (t.Expression | t.SpreadElement | null)[], parentPath: string, result: Map<string, PathInfo>): void;
+export declare function veloPlugin(config?: VeloConfig): PluginOption[];