@getcronit/pylon 3.0.0-canary-20250206125311.f228add1e2e04c8af5d91db6063583bd317de463 → 3.0.0-canary-20250211154244.6f2521705b2882fe77d53141a59749d7cbd96d5c

package/dist/index.d.ts

@@ -8,12 +8,16 @@ export { handler } from './app/pylon-handler.js';
 export { getEnv } from './get-env.js';
 export { createDecorator } from './create-decorator.js';
 export { createPubSub as experimentalCreatePubSub } from 'graphql-yoga';
+export { usePages, type PageProps, PageData } from './plugins/use-pages/index';
 import type { Plugin as YogaPlugin } from 'graphql-yoga';
 import { MiddlewareHandler } from 'hono';
+import { BuildContext, BuildOptions } from 'esbuild';
 export type Plugin<PluginContext extends Record<string, any> = {}, TServerContext extends Record<string, any> = {}, TUserContext = {}> = YogaPlugin<PluginContext, TServerContext, TUserContext> & {
     middleware?: MiddlewareHandler<Env>;
     setup?: (app: typeof pylonApp) => void;
-    build?: () => Promise<void>;
+    build?: <T extends BuildOptions>(args: {
+        onBuild: () => void;
+    }) => Promise<Omit<BuildContext<T>, 'serve'>>;
 };
 export type PylonConfig = {
     landingPage?: boolean;

package/dist/index.js

@@ -636,6 +636,7 @@ function requireAuth(checks) {
 import { Hono } from "hono";
 import { logger } from "hono/logger";
 import { sentry } from "@hono/sentry";
+import { except } from "hono/combine";
 var app = new Hono();
 app.use("*", sentry());
 app.use("*", async (c, next) => {
@@ -649,7 +650,7 @@ app.use("*", async (c, next) => {
     });
   });
 });
-app.use("*", logger());
+app.use("*", except(["/__pylon/static/*"], logger()));
 app.use((c, next) => {
   c.req.id = crypto.randomUUID();
   return next();
@@ -1191,7 +1192,9 @@ function getEnv() {
   const skipTracing = arguments[0] === true;
   try {
     const context = asyncContext.getStore();
-    return context.env || process.env || {};
+    const ctx = context.env || process.env || {};
+    ctx.NODE_ENV = ctx.NODE_ENV || process.env.NODE_ENV || "development";
+    return ctx;
   } catch {
     return process.env;
   } finally {
@@ -1207,6 +1210,647 @@ function getEnv() {
 
 // src/index.ts
 import { createPubSub } from "graphql-yoga";
+
+// src/plugins/use-pages/setup/index.tsx
+import fs2 from "fs";
+import path3 from "path";
+import reactServer from "react-dom/server";
+import { Readable } from "stream";
+
+// src/plugins/use-pages/setup/app-loader.tsx
+import { useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var AppLoader = (props) => {
+  props.client.useHydrateCache({ cacheSnapshot: props.pylonData.cacheSnapshot });
+  const data = props.client.useQuery();
+  const page = useMemo(() => {
+    const page2 = /* @__PURE__ */ jsx(
+      props.App,
+      {
+        pageProps: {
+          ...props.pylonData.pageProps,
+          data
+        }
+      }
+    );
+    return page2;
+  }, [props]);
+  return /* @__PURE__ */ jsx(props.Router, { ...props.routerProps, children: page });
+};
+
+// src/plugins/use-pages/setup/index.tsx
+import { trimTrailingSlash } from "hono/trailing-slash";
+import { StaticRouter } from "react-router";
+import sharp from "sharp";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { pipeline } from "stream/promises";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var disableCacheMiddleware = async (c, next) => {
+  if (c.env.NODE_ENV === "development") {
+    c.header(
+      "Cache-Control",
+      "no-store, no-cache, must-revalidate, proxy-revalidate"
+    );
+    c.header("Pragma", "no-cache");
+    c.header("Expires", "0");
+    c.header("Surrogate-Control", "no-store");
+  }
+  return next();
+};
+var setup = (app2) => {
+  const pagesFilePath = path3.resolve(process.cwd(), ".pylon", "pages.json");
+  let pageRoutes = [];
+  try {
+    pageRoutes = JSON.parse(fs2.readFileSync(pagesFilePath, "utf-8"));
+  } catch (error) {
+    console.error("Error reading pages.json", error);
+  }
+  app2.use(trimTrailingSlash());
+  let App = void 0;
+  let client = void 0;
+  app2.on(
+    "GET",
+    pageRoutes.map((pageRoute) => pageRoute.slug),
+    disableCacheMiddleware,
+    async (c) => {
+      if (!App) {
+        const module = await import(`${process.cwd()}/.pylon/__pylon/pages/app.js`);
+        App = module.default;
+      }
+      if (!client) {
+        client = await import(`${process.cwd()}/.pylon/client`);
+      }
+      const pageProps = {
+        params: c.req.param(),
+        searchParams: c.req.query(),
+        path: c.req.path
+      };
+      let cacheSnapshot = void 0;
+      const prepared = await client.prepareReactRender(
+        /* @__PURE__ */ jsx2(
+          AppLoader,
+          {
+            Router: StaticRouter,
+            routerProps: {
+              location: c.req.path
+            },
+            App,
+            client,
+            pylonData: {
+              pageProps,
+              cacheSnapshot: void 0
+            }
+          }
+        )
+      );
+      cacheSnapshot = prepared.cacheSnapshot;
+      const stream = await reactServer.renderToReadableStream(
+        /* @__PURE__ */ jsx2(
+          AppLoader,
+          {
+            Router: StaticRouter,
+            routerProps: {
+              location: c.req.path
+            },
+            App,
+            client,
+            pylonData: {
+              pageProps,
+              cacheSnapshot: prepared.cacheSnapshot
+            }
+          }
+        ),
+        {
+          bootstrapModules: ["/__pylon/static/app.js"],
+          bootstrapScriptContent: `window.__PYLON_DATA__ = ${JSON.stringify({
+            pageProps,
+            cacheSnapshot
+          })}`
+        }
+      );
+      return c.body(stream);
+    }
+  );
+  app2.get("/__pylon/static/*", disableCacheMiddleware, async (c) => {
+    const filePath = path3.resolve(
+      process.cwd(),
+      ".pylon",
+      "__pylon",
+      "static",
+      c.req.path.replace("/__pylon/static/", "")
+    );
+    if (!fs2.existsSync(filePath)) {
+      throw new Error("File not found");
+    }
+    if (filePath.endsWith(".js")) {
+      c.res.headers.set("Content-Type", "text/javascript");
+    } else if (filePath.endsWith(".css")) {
+      c.res.headers.set("Content-Type", "text/css");
+    } else if (filePath.endsWith(".html")) {
+      c.res.headers.set("Content-Type", "text/html");
+    } else if (filePath.endsWith(".json")) {
+      c.res.headers.set("Content-Type", "application/json");
+    } else if (filePath.endsWith(".png")) {
+      c.res.headers.set("Content-Type", "image/png");
+    } else if (filePath.endsWith(".jpg") || filePath.endsWith(".jpeg")) {
+      c.res.headers.set("Content-Type", "image/jpeg");
+    } else if (filePath.endsWith(".gif")) {
+      c.res.headers.set("Content-Type", "image/gif");
+    } else if (filePath.endsWith(".svg")) {
+      c.res.headers.set("Content-Type", "image/svg+xml");
+    } else if (filePath.endsWith(".ico")) {
+      c.res.headers.set("Content-Type", "image/x-icon");
+    }
+    const stream = fs2.createReadStream(filePath);
+    const a = Readable.toWeb(stream);
+    return c.body(a);
+  });
+  app2.get("/__pylon/image", async (c) => {
+    console.log("image optimization route");
+    try {
+      const { src, w, h, q = "75", format = "webp" } = c.req.query();
+      const queryStringHash = createHash("sha256").update(JSON.stringify(c.req.query())).digest("hex");
+      if (!src) {
+        return c.json({ error: "Missing parameters." }, 400);
+      }
+      let imagePath = path3.join(process.cwd(), ".pylon", src);
+      if (src.startsWith("http://") || src.startsWith("https://")) {
+        imagePath = await downloadImage(src);
+      }
+      try {
+        console.log("imagePath", imagePath);
+        await fs2.promises.access(imagePath);
+      } catch {
+        return c.json({ error: "Image not found" }, 404);
+      }
+      const metadata = await sharp(imagePath).metadata();
+      if (!metadata.width || !metadata.height) {
+        return c.json(
+          {
+            error: "Invalid image metadata. Width and height are required for resizing."
+          },
+          400
+        );
+      }
+      const { width: finalWidth, height: finalHeight } = calculateDimensions(
+        metadata.width,
+        metadata.height,
+        w ? parseInt(w) : void 0,
+        h ? parseInt(h) : void 0
+      );
+      const cachePath = path3.join(IMAGE_CACHE_DIR, queryStringHash);
+      let imageFormat = format.toLowerCase();
+      if (!isSupportedFormat(imageFormat)) {
+        throw new Error("Unsupported image format");
+      }
+      const quality = parseInt(q);
+      console.log("quality", quality);
+      const image = await sharp(imagePath).resize(finalWidth, finalHeight).toFormat(imageFormat, {
+        quality
+      }).toFile(cachePath);
+      console.log("image", image);
+      c.res.headers.set("Content-Type", getContentType(image.format));
+      return c.body(
+        Readable.toWeb(fs2.createReadStream(cachePath))
+      );
+    } catch (error) {
+      console.error("Error processing the image:", error);
+      return c.json({ error: "Error processing the image" }, 500);
+    }
+  });
+};
+var IMAGE_CACHE_DIR = path3.join(process.cwd(), ".cache/__pylon/images");
+fs2.promises.mkdir(IMAGE_CACHE_DIR, { recursive: true });
+var calculateDimensions = (originalWidth, originalHeight, width, height) => {
+  if (!width && !height) {
+    return { width: originalWidth, height: originalHeight };
+  }
+  if (width && !height) {
+    height = Math.round(width * originalHeight / originalWidth);
+  } else if (height && !width) {
+    width = Math.round(height * originalWidth / originalHeight);
+  }
+  return { width, height };
+};
+function isSupportedFormat(format) {
+  const supportedFormats = sharp.format;
+  return Object.keys(supportedFormats).includes(format);
+}
+var getContentType = (format) => {
+  switch (format.toLowerCase()) {
+    case "webp":
+      return "image/webp";
+    case "jpeg":
+    case "jpg":
+      return "image/jpeg";
+    case "png":
+      return "image/png";
+    case "gif":
+      return "image/gif";
+    case "svg":
+      return "image/svg+xml";
+    default:
+      return "application/octet-stream";
+  }
+};
+var downloadImage = async (url) => {
+  const response = await fetch(url);
+  if (!response.ok)
+    throw new Error(`Failed to download image: ${response.statusText}`);
+  const ext = path3.extname(new URL(url).pathname) || ".jpg";
+  const tempFilePath = path3.join(tmpdir(), `image-${Date.now()}${ext}`);
+  const fileStream = fs2.createWriteStream(tempFilePath);
+  await pipeline(response.body, fileStream);
+  return tempFilePath;
+};
+
+// src/plugins/use-pages/build/index.ts
+import path7 from "path";
+
+// src/plugins/use-pages/build/app-utils.ts
+import path4 from "path";
+import glob from "tiny-glob";
+function fnv1aHash(str) {
+  let hash = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    hash ^= str.charCodeAt(i);
+    hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+  return (hash >>> 0).toString(16);
+}
+var APP_DIR = path4.join(process.cwd(), "pages");
+async function getPageRoutes(dir = APP_DIR) {
+  const routes = [];
+  const pagePattern = path4.join(dir, "**/page.{ts,tsx,js}");
+  const layoutPattern = path4.join(dir, "**/layout.tsx");
+  const pageFiles = await glob(pagePattern);
+  const layoutFiles = await glob(layoutPattern);
+  for (const pagePath of pageFiles) {
+    const relativePagePath = path4.relative(APP_DIR, pagePath);
+    let slug = "/" + relativePagePath.replace(/page\.(ts|tsx|js)$/, "").replace(/\[([\w-]+)\]/g, ":$1");
+    slug = slug.replace(/\/$/, "");
+    const layouts = layoutFiles.filter((layout) => {
+      return pagePath.startsWith(layout.replace("layout.tsx", ""));
+    });
+    const layoutsWithoutRootLayout = layouts.slice(1);
+    routes.push({
+      pagePath,
+      slug: slug || "/",
+      layouts: layoutsWithoutRootLayout
+    });
+  }
+  return routes;
+}
+var generateAppFile = (pageRoutes) => {
+  const makePageMap = (routes) => {
+    const pageMap2 = {};
+    for (const route of routes) {
+      pageMap2[route.pagePath] = `Page${fnv1aHash(route.pagePath)}`;
+    }
+    return pageMap2;
+  };
+  const makeLayoutMap = (routes) => {
+    const layoutMap2 = {};
+    for (const route of routes) {
+      for (const layout of route.layouts) {
+        layoutMap2[layout] = `Layout${fnv1aHash(layout)}`;
+      }
+    }
+    return layoutMap2;
+  };
+  const pageMap = makePageMap(pageRoutes);
+  const layoutMap = makeLayoutMap(pageRoutes);
+  const importPages = Object.keys(pageMap).map((pagePath, index) => {
+    const importLocation = `../${pagePath}`.replace(".tsx", ".js");
+    const componentName = pageMap[pagePath];
+    return `const ${componentName} = lazy(() => import('${importLocation}'))
+      `;
+  }).join("\n");
+  const importLayouts = Object.keys(layoutMap).map((layoutPath, index) => {
+    const importLocation = `../${layoutPath}`.replace(".tsx", ".js");
+    const componentName = layoutMap[layoutPath];
+    return `const ${componentName} = lazy(() => import('${importLocation}'))
+      `;
+  }).join("\n");
+  const appComponent = `"use client";
+  import {lazy, Suspense} from 'react'
+  import { Routes, Route } from 'react-router';
+  ${importPages}
+  const RootLayout = lazy(() => import('../pages/layout.js'))
+  ${importLayouts}
+  
+  const App: React.FC<{pageProps: any}> = ({pageProps}) => (
+  <RootLayout>
+      <meta charSet="utf-8" />
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <link rel="stylesheet" href="/__pylon/static/app.css" />
+         <Routes>
+        ${pageRoutes.map((route, index) => {
+    return `<Route key={${index}} index={${index === 0 ? "true" : "false"}} path="${route.slug}" element={
+         <Suspense fallback={<div>...</div>}>
+            ${route.layouts.reduceRight((child, layoutPath, layoutIndex) => {
+      const layoutName = layoutMap[layoutPath];
+      return `<${layoutName}>${child}</${layoutName}>`;
+    }, `<${pageMap[route.pagePath]} {...pageProps} />`)}
+
+         </Suspense>} />`;
+  }).join("\n")}
+    </Routes>
+    </RootLayout>
+  );
+  
+  export default App;
+    `;
+  return appComponent;
+};
+
+// src/plugins/use-pages/build/index.ts
+import chokidar from "chokidar";
+import fs6 from "fs/promises";
+import esbuild from "esbuild";
+
+// src/plugins/use-pages/build/plugins/inject-app-hydration.ts
+import path5 from "path";
+import fs3 from "fs/promises";
+var injectAppHydrationPlugin = {
+  name: "inject-hydration",
+  setup(build2) {
+    build2.onLoad({ filter: /.*/, namespace: "file" }, async (args) => {
+      if (args.path === path5.resolve(process.cwd(), ".pylon", "app.tsx")) {
+        let contents = await fs3.readFile(args.path, "utf-8");
+        const clientPath = path5.resolve(process.cwd(), ".pylon/client");
+        const pathToClient = path5.relative(path5.dirname(args.path), clientPath);
+        contents += `
+          import {hydrateRoot} from 'react-dom/client'
+          import * as client from './${pathToClient}'
+          import {BrowserRouter} from 'react-router'
+          import React, {useMemo} from 'react'
+
+          const pylonData = window.__PYLON_DATA__
+
+          console.log('pylonData', pylonData)
+
+          const AppLoader = (props: {
+            client: any
+            pylonData: {
+              pageProps: Omit<PageProps, 'data'>
+              cacheSnapshot?: any
+            }
+            App: React.FC<{
+              pageProps: PageProps
+            }>
+            Router: React.FC<any>
+            routerProps: any
+          }) => {
+            props.client.useHydrateCache({cacheSnapshot: props.pylonData.cacheSnapshot})
+          
+            const data = props.client.useQuery()
+            const page = useMemo(() => {
+              const page = (
+                <props.App
+                  pageProps={{
+                    ...props.pylonData.pageProps,
+                    data
+                  }}
+                />
+              )
+          
+              return page
+            }, [props])
+          
+            return <props.Router {...props.routerProps}>{page}</props.Router>
+          }
+          
+
+          hydrateRoot(
+          document,
+            <AppLoader Router={BrowserRouter} client={client} pylonData={pylonData} App={App} />
+          )
+          `;
+        return {
+          loader: "tsx",
+          contents
+        };
+      }
+    });
+  }
+};
+
+// src/plugins/use-pages/build/plugins/image-plugin.ts
+import { createHash as createHash2 } from "crypto";
+import path6 from "path";
+import sharp2 from "sharp";
+import fs4 from "fs/promises";
+var imagePlugin = {
+  name: "image-plugin",
+  setup(build2) {
+    const outdir = build2.initialOptions.outdir;
+    const publicPath = build2.initialOptions.publicPath;
+    if (!outdir || !publicPath) {
+      throw new Error("outdir and publicPath must be set in esbuild options");
+    }
+    build2.onResolve({ filter: /\.(png|jpe?g)$/ }, async (args) => {
+      const filePath = path6.resolve(args.resolveDir, args.path);
+      const fileName = path6.basename(filePath);
+      const extname = path6.extname(filePath);
+      const hash = createHash2("md5").update(filePath + await fs4.readFile(filePath)).digest("hex").slice(0, 8);
+      const newFilename = `${fileName}-${hash}${extname}`;
+      const newFilePath = path6.join(outdir, "media", newFilename);
+      await fs4.mkdir(path6.dirname(newFilePath), { recursive: true });
+      await fs4.copyFile(filePath, newFilePath);
+      return {
+        path: newFilePath,
+        namespace: "image"
+      };
+    });
+    build2.onLoad({ filter: /\.png$|\.jpg$/ }, async (args) => {
+      const image = sharp2(args.path);
+      const metadata = await image.metadata();
+      const url = `${publicPath}/media/${path6.basename(args.path)}`;
+      const searchParams = new URLSearchParams({});
+      if (metadata.width) {
+        searchParams.set("w", metadata.width.toString());
+      }
+      if (metadata.height) {
+        searchParams.set("h", metadata.height.toString());
+      }
+      const output = image.resize({
+        width: Math.min(metadata.width ?? 16, 16),
+        height: Math.min(metadata.height ?? 16, 16),
+        fit: "inside"
+      }).toFormat("webp", {
+        quality: 20,
+        alphaQuality: 20,
+        smartSubsample: true
+      });
+      const { data, info } = await output.toBuffer({ resolveWithObject: true });
+      const dataURIBase64 = `data:image/${info.format};base64,${data.toString(
+        "base64"
+      )}`;
+      if (dataURIBase64) {
+        searchParams.set("blurDataURL", dataURIBase64);
+      }
+      return {
+        contents: `${url}?${searchParams.toString()}`,
+        loader: "text"
+      };
+    });
+  }
+};
+
+// src/plugins/use-pages/build/plugins/postcss-plugin.ts
+import fs5 from "fs/promises";
+import loadConfig from "postcss-load-config";
+import postcss from "postcss";
+var postcssPlugin = {
+  name: "postcss-plugin",
+  setup(build2) {
+    build2.onLoad({ filter: /.css$/, namespace: "file" }, async (args) => {
+      const { plugins, options } = await loadConfig();
+      const css = await fs5.readFile(args.path, "utf-8");
+      const result = await postcss(plugins).process(css, {
+        ...options,
+        from: args.path
+      }).then((result2) => result2);
+      return {
+        contents: result.css,
+        loader: "css"
+      };
+    });
+  }
+};
+
+// src/plugins/use-pages/build/index.ts
+var DIST_STATIC_DIR = path7.join(process.cwd(), ".pylon/__pylon/static");
+var DIST_PAGES_DIR = path7.join(process.cwd(), ".pylon/__pylon/pages");
+async function updateFileIfChanged(path8, newContent) {
+  try {
+    const currentContent = await fs6.readFile(path8, "utf8");
+    if (currentContent === newContent) {
+      return false;
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  await fs6.writeFile(path8, newContent, "utf8");
+  return true;
+}
+var build = async () => {
+  const buildAppFile = async () => {
+    const pagesRoutes = await getPageRoutes();
+    const appContent = generateAppFile(pagesRoutes);
+    const appFilePath = path7.resolve(process.cwd(), ".pylon", "app.tsx");
+    const state = await updateFileIfChanged(appFilePath, appContent);
+    if (state) {
+      console.log("Updated app file");
+    }
+  };
+  const writeOnEndPlugin = {
+    name: "write-on-end",
+    setup(build2) {
+      build2.onEnd(async (result) => {
+        result.outputFiles?.forEach(async (file) => {
+          await fs6.mkdir(path7.dirname(file.path), { recursive: true });
+          await updateFileIfChanged(file.path, file.text);
+        });
+      });
+    }
+  };
+  let pagesWatcher = null;
+  const clientCtx = await esbuild.context({
+    write: false,
+    metafile: true,
+    absWorkingDir: process.cwd(),
+    plugins: [
+      injectAppHydrationPlugin,
+      imagePlugin,
+      postcssPlugin,
+      writeOnEndPlugin
+    ],
+    publicPath: "/__pylon/static",
+    assetNames: "assets/[name]-[hash]",
+    chunkNames: "chunks/[name]-[hash]",
+    format: "esm",
+    platform: "browser",
+    entryPoints: [".pylon/app.tsx"],
+    outdir: DIST_STATIC_DIR,
+    bundle: true,
+    splitting: true,
+    minify: false,
+    loader: {
+      // Map file extensions to the file loader
+      ".svg": "file",
+      ".woff": "file",
+      ".woff2": "file"
+    },
+    define: {
+      "process.env.NODE_ENV": '"production"'
+    },
+    mainFields: ["browser", "module", "main"]
+  });
+  const serverCtx = await esbuild.context({
+    write: false,
+    absWorkingDir: process.cwd(),
+    plugins: [imagePlugin, postcssPlugin, writeOnEndPlugin],
+    publicPath: "/__pylon/static",
+    assetNames: "assets/[name]-[hash]",
+    chunkNames: "chunks/[name]-[hash]",
+    format: "esm",
+    platform: "node",
+    entryPoints: [".pylon/app.tsx"],
+    outdir: DIST_PAGES_DIR,
+    bundle: true,
+    packages: "external",
+    splitting: false,
+    minify: false,
+    loader: {
+      // Map file extensions to the file loader
+      ".svg": "file",
+      ".woff": "file",
+      ".woff2": "file"
+    }
+  });
+  return {
+    watch: async () => {
+      console.log("Watching pages directory...");
+      pagesWatcher = chokidar.watch("pages", { ignoreInitial: false });
+      pagesWatcher.on("all", (event, path8) => {
+        if (["add", "change", "unlink"].includes(event)) {
+          buildAppFile();
+        }
+      });
+      await Promise.all([clientCtx.watch(), serverCtx.watch()]);
+    },
+    dispose: async () => {
+      console.log("Disposing pages");
+      if (pagesWatcher) {
+        pagesWatcher.close();
+      }
+      Promise.all([clientCtx.dispose(), serverCtx.dispose()]);
+    },
+    rebuild: async () => {
+      console.log("Rebuilding pages");
+      await buildAppFile();
+      await Promise.all([clientCtx.rebuild(), serverCtx.rebuild()]);
+      return {};
+    },
+    cancel: async () => {
+      if (pagesWatcher) {
+        await pagesWatcher.close();
+      }
+      await Promise.all([clientCtx.cancel(), serverCtx.cancel()]);
+    }
+  };
+};
+
+// src/plugins/use-pages/index.ts
+function usePages() {
+  return {
+    setup,
+    build
+  };
+}
 export {
   ServiceError,
   app,
@@ -1219,6 +1863,7 @@ export {
   handler,
   requireAuth,
   setContext,
-  useAuth
+  useAuth,
+  usePages
 };
 //# sourceMappingURL=index.js.map