xpine 0.0.4 → 0.0.5

package/dist/index.js

@@ -0,0 +1,659 @@
+// src/runDevServer.ts
+import expressWs from "express-ws";
+import http from "http";
+import express from "express";
+import EventEmitter from "events";
+import chokidar from "chokidar";
+
+// src/scripts/build.ts
+import path3 from "path";
+import fs2 from "fs-extra";
+import { build } from "esbuild";
+import builtinModules from "builtin-modules";
+import ts2 from "typescript";
+
+// src/build/typescript-builder.ts
+import ts from "typescript";
+import fs from "fs-extra";
+import path from "path";
+function findDataAttributesAndFunctions(node, sourceFile, foundDataAttributes = [], foundFunctions = []) {
+  if (node.kind === ts.SyntaxKind.JsxAttribute) {
+    const attribute = getAttributeValuePair(node, sourceFile);
+    if (attribute?.[0] === "x-data" && attribute?.[1]) {
+      foundDataAttributes.push(attribute[1].replace(/[^a-zA-Z0-9]/g, ""));
+    }
+  }
+  if (node.kind === ts.SyntaxKind.SourceFile) {
+    node.forEachChild((child) => {
+      if ([ts.SyntaxKind.FunctionDeclaration, ts.SyntaxKind.VariableDeclaration].includes(child.kind)) {
+        const functions = getFunctionDeclarationValue(child, sourceFile);
+        foundFunctions.push(functions);
+      }
+    });
+  }
+  node.forEachChild((child) => {
+    findDataAttributesAndFunctions(child, sourceFile, foundDataAttributes, foundFunctions);
+  });
+  return {
+    foundDataAttributes,
+    foundFunctions
+  };
+}
+function getAttributeValuePair(node, sourceFile) {
+  const result = [];
+  node.forEachChild((child) => {
+    result.push(child.getText(sourceFile));
+  });
+  return result;
+}
+function getFunctionDeclarationValue(node, sourceFile) {
+  const result = {
+    name: null,
+    isDefaultExport: false,
+    hasExport: false
+  };
+  node.forEachChild((child) => {
+    if (child.kind === ts.SyntaxKind.ExportKeyword) {
+      result.hasExport = true;
+    }
+    if (child.kind === ts.SyntaxKind.DefaultKeyword) {
+      result.isDefaultExport = true;
+    }
+    if (child.kind === ts.SyntaxKind.Identifier) {
+      result.name = child.getText(sourceFile);
+    }
+  });
+  return result;
+}
+function convertEntryPointsToSingleFile(entryPoints, tempWritePath) {
+  fs.writeFileSync(
+    tempWritePath,
+    entryPoints.map((entry) => `import "${entry}"`).join(";\n")
+  );
+}
+function removeClientScriptInTSXFile(pathName) {
+  const content = fs.readFileSync(pathName, "utf-8");
+  const source = ts.createSourceFile(
+    pathName,
+    content,
+    ts.ScriptTarget.Latest
+  );
+  let toRemoveFrom;
+  let clientDataStart;
+  const clientImportsToHoist = [];
+  const clientImportsToReplace = [];
+  source.forEachChild((child) => {
+    if (child.kind === ts.SyntaxKind.ExpressionStatement) {
+      const text = child.getText(source);
+      if (text.startsWith("<script")) {
+        toRemoveFrom = child.pos;
+        clientDataStart = child.end;
+      }
+    }
+    if (child.kind === ts.SyntaxKind.ImportDeclaration && child.pos >= clientDataStart) {
+      const text = child.getText(source);
+      child.forEachChild((child2) => {
+        if (child2.kind === ts.SyntaxKind.StringLiteral) {
+          const text2 = child2.getText(source);
+          const importPath = text2.replace(/[\"\']/g, "");
+          const isRelativeImport = importPath.startsWith(".") || importPath.startsWith("/");
+          if (!isRelativeImport) return;
+          clientImportsToReplace.push({
+            old: importPath,
+            new: path.join(path.dirname(pathName), importPath)
+          });
+        }
+      });
+      clientImportsToHoist.push(text);
+    }
+  });
+  let clientContent = !isNaN(clientDataStart) ? content.slice(clientDataStart) : "";
+  for (const clientImport of clientImportsToReplace) {
+    clientContent = clientContent.replace(clientImport.old, clientImport.new);
+  }
+  return {
+    content: !isNaN(toRemoveFrom) ? clientImportsToHoist.join("\n") + content.slice(0, toRemoveFrom) : content,
+    clientContent,
+    fullContent: content,
+    toRemoveFrom,
+    clientDataStart
+  };
+}
+
+// src/scripts/build.ts
+import { globSync } from "glob";
+import postcss from "postcss";
+import tailwindPostcss from "@tailwindcss/postcss";
+
+// src/util/get-config.ts
+import path2 from "path";
+
+// src/util/require.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var require_default = require2;
+
+// src/util/get-config.ts
+var rootDir = process.cwd();
+function fromRoot(pathName) {
+  if (!pathName) return rootDir;
+  return path2.join(rootDir, pathName);
+}
+var userConfig = require_default(path2.join(process.cwd(), "./xpine.config.mjs")).default;
+var configDefaults = {
+  rootDir: fromRoot(),
+  srcDir: fromRoot("./src"),
+  distDir: fromRoot("./dist"),
+  packageJsonPath: fromRoot("package.json"),
+  // We need to use getters here in the event someone wants to change folders, such as the dist folder
+  get distPublicDir() {
+    return path2.join(this.distDir, "./public");
+  },
+  get distPublicScriptsDir() {
+    return path2.join(this.distPublicDir, "./scripts");
+  },
+  get distTempFolder() {
+    return path2.join(this.distDir, "./temp");
+  },
+  get clientJSBundlePath() {
+    return path2.join(this.distPublicScriptsDir, "./app.js");
+  },
+  get alpineDataPath() {
+    return path2.join(this.distTempFolder, "./alpine-data.ts");
+  },
+  get serverDistDir() {
+    return path2.join(this.distDir, "./server");
+  },
+  get serverDistAppPath() {
+    return path2.join(this.serverDistDir, "./app.js");
+  },
+  // Important dirs/paths
+  get pagesDir() {
+    return path2.join(this.srcDir, "./pages");
+  },
+  get publicDir() {
+    return path2.join(this.srcDir, "./public");
+  },
+  get serverDir() {
+    return path2.join(this.srcDir, "./server");
+  },
+  get runDir() {
+    return path2.join(this.serverDir, "./run");
+  },
+  get serverAppPath() {
+    return path2.join(this.serverDir, "./app.ts");
+  },
+  get globalCSSFile() {
+    return path2.join(this.publicDir, "./styles/global.css");
+  }
+};
+var config = {
+  ...configDefaults,
+  ...userConfig
+};
+
+// src/scripts/build.ts
+var extensions = [".ts", ".tsx"];
+var packageJson = JSON.parse(fs2.readFileSync(config.packageJsonPath, "utf-8"));
+var allPackages = Object.keys(packageJson.devDependencies).concat(Object.keys(packageJson.dependencies));
+var allPackagesIncludingNode = allPackages.concat(builtinModules);
+async function buildApp(isDev = false) {
+  try {
+    const srcDirFiles = globSync(config.srcDir + "/**/*.{js,ts,tsx,jsx}");
+    const { componentData, dataFiles } = await buildAppFiles(srcDirFiles, isDev);
+    const alpineDataFile = await buildAlpineDataFile(componentData, dataFiles);
+    await buildClientSideFiles([alpineDataFile], isDev);
+    fs2.removeSync(config.distTempFolder);
+    await buildCSS();
+    await buildPublicFolderSymlinks();
+  } catch (err) {
+    console.error("Build failed");
+    console.error(err);
+  }
+}
+async function buildAppFiles(files, isDev) {
+  const componentData = [];
+  const dataFiles = [];
+  const backendFiles = files.filter((file) => extensions.find((ext) => file.endsWith(ext))).filter((file) => !file.startsWith(config.publicDir));
+  fs2.ensureDirSync(config.distDir);
+  await build({
+    entryPoints: backendFiles,
+    format: "esm",
+    platform: "node",
+    outdir: config.distDir,
+    bundle: true,
+    sourcemap: isDev ? "inline" : false,
+    external: allPackages,
+    jsx: "transform",
+    minify: !isDev,
+    plugins: [
+      {
+        name: "add-dot-js",
+        setup(build2) {
+          build2.onResolve({ filter: /.*/ }, (args) => {
+            const hasAtSign = args.path.startsWith("@");
+            const isPackage = hasAtSign ? allPackagesIncludingNode.includes(args.path) : allPackagesIncludingNode.includes(args.path.split("/").shift());
+            if (args.importer && !isPackage) {
+              const calculatedDir = path3.join(args.resolveDir, args.path);
+              let existsAsFile = false;
+              for (const extension of extensions) {
+                const asFile = calculatedDir + extension;
+                const exists = fs2.existsSync(asFile);
+                if (exists) existsAsFile = true;
+              }
+              let outputPath = args.path + (existsAsFile ? "" : "/index") + ".js";
+              outputPath = args.path.endsWith(".js") || args.path.endsWith(".mjs") ? args.path : outputPath;
+              return { path: outputPath, external: true };
+            }
+          });
+        }
+      },
+      {
+        name: "insert-html-banner-and-remove-client-scripts",
+        setup(build2) {
+          build2.onLoad({ filter: /.tsx/ }, (args) => {
+            const cleanedContent = removeClientScriptInTSXFile(args.path);
+            const htmlImportStart = "import { html } from 'xpine';\n";
+            const newContent = `${htmlImportStart}${cleanedContent.content}`;
+            componentData.push({
+              ...args,
+              contents: `${htmlImportStart}${cleanedContent.fullContent}`,
+              clientContent: cleanedContent.clientContent
+            });
+            return {
+              contents: newContent,
+              loader: "tsx"
+            };
+          });
+        }
+      },
+      {
+        name: "get-data-files",
+        setup(build2) {
+          build2.onLoad({ filter: /\.data\.(js|mjs|ts)$/ }, (args) => {
+            const contents = fs2.readFileSync(args.path, "utf-8");
+            dataFiles.push({
+              ...args,
+              contents
+            });
+            return {
+              contents,
+              loader: "ts"
+            };
+          });
+        }
+      }
+    ]
+  });
+  await logSize(config.distDir, "app");
+  return {
+    componentData,
+    dataFiles
+  };
+}
+async function buildClientSideFiles(alpineDataFiles = [], isDev) {
+  const tempFilePath = path3.join(config.distTempFolder, "./app.ts");
+  fs2.ensureFileSync(tempFilePath);
+  const pagesScriptsGlob = config.publicDir + "/scripts/pages/**/*.{js,ts}";
+  const clientFiles = globSync(
+    config.publicDir + "/**/*.{js,ts}",
+    {
+      ignore: pagesScriptsGlob
+    }
+  );
+  convertEntryPointsToSingleFile(alpineDataFiles.concat(clientFiles), tempFilePath);
+  if (isDev) writeDevServerClientSideCode(tempFilePath);
+  writeSpaClientSideCode(tempFilePath);
+  await build({
+    entryPoints: [tempFilePath],
+    bundle: true,
+    outdir: config.distPublicScriptsDir,
+    minify: !isDev,
+    sourcemap: isDev ? "inline" : false
+  });
+  const pagesFiles = globSync(pagesScriptsGlob);
+  await build({
+    entryPoints: pagesFiles || [],
+    bundle: true,
+    outdir: config.distPublicScriptsDir + "/pages",
+    minify: !isDev,
+    sourcemap: isDev ? "inline" : false
+  });
+  await logSize(config.distPublicDir, "client");
+}
+function writeDevServerClientSideCode(tempFilePath) {
+  const devServerPath = path3.join(import.meta.dirname, "../static/dev-server.js");
+  const content = fs2.readFileSync(devServerPath, "utf-8");
+  fs2.appendFileSync(tempFilePath, `
+` + content);
+}
+function writeSpaClientSideCode(tempFilePath) {
+  const spaPath = path3.join(import.meta.dirname, "../static/spa.js");
+  const content = fs2.readFileSync(spaPath, "utf-8");
+  fs2.appendFileSync(tempFilePath, `
+` + content);
+}
+async function buildAlpineDataFile(componentData, dataFiles) {
+  const output = {
+    imports: [
+      "import Alpine from 'alpinejs';"
+    ],
+    code: [],
+    end: [
+      "window.Alpine = Alpine;"
+    ]
+  };
+  const dataFunctionResults = {
+    foundDataAttributes: [],
+    foundFunctions: [],
+    foundImports: []
+  };
+  const componentsAndDataFiles = componentData.concat(dataFiles);
+  for (const component of componentsAndDataFiles) {
+    const sourceFile = ts2.createSourceFile(
+      component.path,
+      component.contents,
+      ts2.ScriptTarget.Latest
+    );
+    const dataFunctionResult = findDataAttributesAndFunctions(sourceFile, sourceFile);
+    dataFunctionResults.foundDataAttributes.push(...dataFunctionResult.foundDataAttributes);
+    const foundFunctionsWithPath = dataFunctionResult.foundFunctions.map((item) => {
+      return {
+        ...item,
+        path: component.path,
+        content: component.clientContent
+      };
+    });
+    dataFunctionResults.foundFunctions.push(...foundFunctionsWithPath);
+  }
+  const validDataFunctions = dataFunctionResults.foundFunctions.filter((item) => {
+    return dataFunctionResults.foundDataAttributes.includes(item.name) && item.content;
+  });
+  for (const dataFunction of validDataFunctions) {
+    if (!dataFunction.hasExport) continue;
+    output.code.push(dataFunction.content);
+    output.code.push(`Alpine.data('${dataFunction.name}', ${dataFunction.name});`);
+  }
+  const result = output.imports.join("\n") + "\n" + output.code.join("\n") + "\n" + output.end.join("\n");
+  fs2.ensureFileSync(config.alpineDataPath);
+  fs2.writeFileSync(config.alpineDataPath, result);
+  return config.alpineDataPath;
+}
+async function buildCSS() {
+  const cssFiles = globSync(config.srcDir + "/**/*.css");
+  for (const file of cssFiles) {
+    const fileContents = fs2.readFileSync(file, "utf-8");
+    const result = await postcss([tailwindPostcss()]).process(fileContents, { from: file });
+    const newPath = file.replace(config.srcDir, config.distDir);
+    fs2.ensureFileSync(newPath);
+    fs2.writeFileSync(newPath, result.css);
+  }
+  logSize(config.distPublicDir, "css");
+}
+async function buildPublicFolderSymlinks() {
+  const files = globSync(config.publicDir + "/**/*.*", {
+    ignore: "/**/*.{css,js,ts,tsx,jsx}"
+  });
+  for (const file of files) {
+    try {
+      const newPath = file.replace(config.srcDir, config.distDir);
+      const splitNewPath = newPath.split("/");
+      splitNewPath.pop();
+      const newDir = splitNewPath.join("/");
+      fs2.ensureDirSync(newDir);
+      fs2.symlinkSync(file, newPath);
+    } catch {
+    }
+  }
+}
+async function logSize(pathName, type, validExtensions = [".js", ".css"]) {
+  const files = globSync(pathName + "/**/*" + (type === "css" ? ".css" : ""));
+  const fileSizes = files.map((file) => {
+    if (!validExtensions.find((ext) => file.endsWith(ext))) return false;
+    return {
+      file,
+      size: fs2.statSync(file).size / (1024 * 1e3)
+    };
+  }).filter(Boolean);
+  const totalSize = fileSizes.reduce((total, current) => {
+    return current.size + total;
+  }, 0);
+  console.info(`[${totalSize.toFixed(3)} MB] Built ${type}`);
+}
+
+// src/runDevServer.ts
+import path5 from "path";
+
+// src/util/env.ts
+import dotenv from "dotenv";
+import path4 from "path";
+function setupEnv() {
+  dotenv.config({ path: path4.join(config.rootDir, `./.env.${process.env.STAGE || "dev"}`) });
+}
+
+// src/runDevServer.ts
+setupEnv();
+async function runDevServer() {
+  process.env.NODE_ENV = "development";
+  const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
+  await buildApp(true);
+  let appServer = await startServer.default();
+  const watcher = chokidar.watch(config.srcDir, {
+    ignoreInitial: true,
+    // Ignore map and prisma files
+    ignored: (pathName) => pathName.endsWith(".map") || pathName.startsWith(path5.join(config.serverDir, "./prisma"))
+  });
+  watcher.on("all", async (event, path6) => {
+    const shouldReloadServer = path6.startsWith(config.serverDir) && !path6.startsWith(config.runDir) || ["add", "unlink"].includes(event) && path6.startsWith(config.pagesDir);
+    if (shouldReloadServer) {
+      appServer.server.close();
+      await buildApp(true);
+      const startServer2 = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
+      appServer = await startServer2.default();
+      return;
+    }
+    await buildApp(true);
+    refreshEmitter.emit("refresh");
+  });
+  const wsApp = express();
+  const wsServer = http.createServer(wsApp);
+  expressWs(wsApp, wsServer);
+  class RefreshEmitter extends EventEmitter {
+  }
+  ;
+  const refreshEmitter = new RefreshEmitter();
+  wsApp.ws("/dev-server", function(ws) {
+    refreshEmitter.removeAllListeners();
+    refreshEmitter.on("refresh", () => {
+      ws.send("refresh:client");
+    });
+  });
+  const wsPort = 3001;
+  wsServer.listen(wsPort);
+  wsServer.on("listening", () => {
+    console.info(`Dev server listening on port ${wsPort}`);
+  });
+}
+
+// src/express.ts
+import express2 from "express";
+import { globSync as globSync2 } from "glob";
+
+// src/auth.ts
+import jsonwebtoken from "jsonwebtoken";
+var { verify, sign } = jsonwebtoken;
+async function signUser(email, username) {
+  return new Promise((resolve, reject) => {
+    sign(
+      {
+        user: {
+          email,
+          username
+        }
+      },
+      // @ts-ignore
+      process.env.JWT_PRIVATE_KEY,
+      { expiresIn: "30d" },
+      (err, token) => {
+        if (err) reject(err);
+        resolve(token);
+      }
+    );
+  });
+}
+async function verifyUser(token) {
+  return new Promise((resolve, reject) => {
+    verify(token, process.env.JWT_PRIVATE_KEY, (err, authorizedData) => {
+      if (err) reject(err);
+      resolve(authorizedData);
+    });
+  });
+}
+function getTokenFromRequest(req) {
+  const { authorization } = req.headers;
+  if (!authorization) return null;
+  const token = authorization.split(" ").pop() || "";
+  return token || null;
+}
+
+// src/express.ts
+import requestIP from "request-ip";
+var doctypeHTML = "<!DOCTYPE html>";
+async function createRouter() {
+  const methods = ["get", "post", "put", "patch", "delete"];
+  const router = express2.Router();
+  const routes = globSync2(config.pagesDir + "/**/*.{tsx,ts}");
+  const routeMap = routes.map((route) => {
+    return {
+      route: route.split(config.pagesDir).pop().replace(".tsx", "").replace(".js", "").replace(".ts", "").replace("/index", "/"),
+      path: route.replace(config.srcDir, config.distDir).replace(".tsx", ".js").replace(".ts", ".js"),
+      originalRoute: route
+    };
+  });
+  const routeResults = [];
+  for (const route of routeMap) {
+    const isJSX = route.originalRoute.endsWith(".tsx") || route.originalRoute.endsWith(".jsx");
+    const routeItem = process.env.NODE_ENV === "development" ? null : (await import(route.path)).default;
+    const slugRoute = route.route.toLowerCase().replace(/[ ]/g, "");
+    const foundMethod = methods.find((method) => slugRoute.endsWith(`.${method}`));
+    const isDynamicRoute = slugRoute.match(/\[(.*)\]/g);
+    let formattedRouteItem = slugRoute;
+    if (foundMethod) formattedRouteItem = formattedRouteItem.split(".").shift();
+    if (isDynamicRoute) {
+      const result = [...formattedRouteItem.matchAll(/(\[)(.*?)(\])/g)];
+      for (const match of result) {
+        formattedRouteItem = formattedRouteItem.replace(match[0], ":" + match[2]);
+      }
+    }
+    routeResults.push({
+      formattedRouteItem,
+      foundMethod,
+      route
+    });
+    router[foundMethod || "get"](formattedRouteItem, async (req, res) => {
+      try {
+        if (routeItem) {
+          if (isJSX) {
+            res.send(doctypeHTML + await routeItem(req, res));
+          } else {
+            await routeItem(req, res);
+          }
+          return;
+        }
+        const defaultRouteImport = (await import(route.path + `?cache=${Date.now()}`)).default;
+        if (isJSX) {
+          res.send(doctypeHTML + await defaultRouteImport(req, res));
+        } else {
+          await defaultRouteImport(req, res);
+        }
+      } catch (err) {
+        console.error(err);
+        res.status(err?.status || 500).send(err?.message || "Error");
+      }
+    });
+  }
+  return {
+    router,
+    routeResults
+  };
+}
+async function verifyUserMiddleware(req, _res, next) {
+  const { usertoken } = req.cookies;
+  if (!usertoken) {
+    req.user = null;
+  }
+  try {
+    const { user } = await verifyUser(usertoken);
+    req.user = user;
+  } catch (err) {
+    req.user = null;
+  }
+  next();
+}
+async function createXPineRouter(app, beforeErrorRoute) {
+  app.use(express2.static(config.distPublicDir));
+  app.use(verifyUserMiddleware);
+  app.use(requestIP.mw());
+  const { router, routeResults } = await createRouter();
+  app.use(function replaceableRouter(req, res, next) {
+    router(req, res, next);
+  });
+  const found404 = routeResults?.find((item) => item?.formattedRouteItem === "/404");
+  const import404 = process.env.NODE_ENV === "development" ? null : (await import(found404.route.path)).default;
+  if (beforeErrorRoute) beforeErrorRoute(app);
+  app.use(async function(req, res) {
+    res.status(404);
+    if (import404) {
+      res.send(doctypeHTML + await import404(req, res));
+    } else if (found404 && process.env.NODE_ENV === "development") {
+      const import404Item = (await import(found404.route.path + `?cache=${Date.now()}`)).default;
+      res.send(doctypeHTML + await import404Item(req, res));
+    } else {
+      res.send("Error");
+    }
+  });
+}
+
+// src/util/html.ts
+var html = class {
+  static attributeObjectToString(props) {
+    if (!props) return "";
+    return Object.entries(props).filter(([, value]) => value !== null && value !== void 0).map(([key, value], index) => {
+      const start = index === 0 ? " " : "";
+      return `${start}${key}="${value}"`;
+    }).join(" ");
+  }
+  static async fragment(props) {
+    const childrenResult = await Promise.all(props.children.flat());
+    return childrenResult.filter(Boolean).join("");
+  }
+  static async createElement(type, props, ...children) {
+    const childrenResult = await Promise.all(children.flat());
+    if (typeof type === "function") {
+      const result = await type({ ...props, children: childrenResult });
+      return result;
+    }
+    return `<${type}${this.attributeObjectToString(props)}>${childrenResult.filter(Boolean).join("")}</${type}>`;
+  }
+};
+function JSXRuntime() {
+  return true;
+}
+export {
+  JSXRuntime,
+  buildApp,
+  buildCSS,
+  buildPublicFolderSymlinks,
+  config,
+  createRouter,
+  createXPineRouter,
+  fromRoot,
+  getTokenFromRequest,
+  html,
+  logSize,
+  runDevServer,
+  setupEnv,
+  signUser,
+  verifyUser
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/runDevServer.ts", "../src/scripts/build.ts", "../src/build/typescript-builder.ts", "../src/util/get-config.ts", "../src/util/require.ts", "../src/util/env.ts", "../src/express.ts", "../src/auth.ts", "../src/util/html.ts"],
  "sourcesContent": ["import expressWs from 'express-ws';\nimport http from 'http';\nimport express from 'express';\nimport EventEmitter from 'events';\nimport chokidar from 'chokidar';\nimport { buildApp } from './scripts/build';\nimport path from 'path';\nimport { config } from './util/get-config';\nimport { setupEnv } from './util/env';\n\nsetupEnv();\n\nexport async function runDevServer() {\n  process.env.NODE_ENV = 'development';\n  const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);\n\n  // Initial server set up\n  await buildApp(true);\n  let appServer = await startServer.default();\n\n  // Watch files\n  const watcher = chokidar.watch(config.srcDir, {\n    ignoreInitial: true,\n    // Ignore map and prisma files\n    ignored: (pathName) => pathName.endsWith('.map') || pathName.startsWith(path.join(config.serverDir, './prisma')),\n  });\n  watcher.on('all', async (event, path) => {\n    const shouldReloadServer = (path.startsWith(config.serverDir) && !path.startsWith(config.runDir)) ||\n      ['add', 'unlink'].includes(event) && path.startsWith(config.pagesDir);\n    if (shouldReloadServer) {\n      // We modified files in the server, restart the server\n      appServer.server.close();\n      await buildApp(true);\n      const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);\n      appServer = await startServer.default();\n      return;\n    }\n    await buildApp(true);\n    refreshEmitter.emit('refresh');\n  });\n\n  // Create web socket sever\n  const wsApp = express();\n  const wsServer = http.createServer(wsApp);\n  expressWs(wsApp, wsServer);\n  class RefreshEmitter extends EventEmitter { };\n  const refreshEmitter = new RefreshEmitter();\n\n  // @ts-ignore\n  wsApp.ws('/dev-server', function (ws) {\n    refreshEmitter.removeAllListeners();\n    refreshEmitter.on('refresh', () => {\n      ws.send('refresh:client');\n    });\n  });\n\n  const wsPort = 3001;\n  wsServer.listen(wsPort);\n  wsServer.on('listening', () => {\n    console.info(`Dev server listening on port ${wsPort}`);\n  });\n}\n\n\n", "import path from 'path';\nimport fs from 'fs-extra';\nimport { build } from 'esbuild';\nimport builtinModules from 'builtin-modules';\nimport ts from 'typescript';\nimport {\n  convertEntryPointsToSingleFile,\n  findDataAttributesAndFunctions,\n  removeClientScriptInTSXFile\n} from '../build/typescript-builder';\nimport { globSync } from 'glob';\nimport postcss from 'postcss';\n// @ts-ignore\nimport tailwindPostcss from '@tailwindcss/postcss';\nimport { config } from '../util/get-config';\n\n// Extensions to look for in the bundle\nconst extensions = ['.ts', '.tsx'];\nconst packageJson = JSON.parse(fs.readFileSync(config.packageJsonPath, 'utf-8'));\nconst allPackages = Object.keys(packageJson.devDependencies).concat(Object.keys(packageJson.dependencies));\nconst allPackagesIncludingNode = allPackages.concat(builtinModules);\n\nexport async function buildApp(isDev = false) {\n  try {\n    const srcDirFiles = globSync(config.srcDir + '/**/*.{js,ts,tsx,jsx}');\n    const { componentData, dataFiles, } = await buildAppFiles(srcDirFiles, isDev);\n    const alpineDataFile = await buildAlpineDataFile(componentData, dataFiles);\n    await buildClientSideFiles([alpineDataFile], isDev);\n    fs.removeSync(config.distTempFolder);\n    await buildCSS();\n    await buildPublicFolderSymlinks();\n  } catch (err) {\n    console.error('Build failed');\n    console.error(err);\n  }\n}\n\nasync function buildAppFiles(files: string[], isDev?: boolean) {\n  const componentData = [];\n  const dataFiles = [];\n  // Filter out client side files and files that aren't of the allowed extensions\n  const backendFiles = files\n    .filter((file) => extensions.find(ext => file.endsWith(ext)))\n    .filter((file) => !file.startsWith(config.publicDir));\n  fs.ensureDirSync(config.distDir);\n  // Build backend/SSR TSX modules\n  await build({\n    entryPoints: backendFiles,\n    format: 'esm',\n    platform: 'node',\n    outdir: config.distDir,\n    bundle: true,\n    sourcemap: isDev ? 'inline' : false,\n    external: allPackages,\n    jsx: 'transform',\n    minify: !isDev,\n    plugins: [\n      {\n        name: 'add-dot-js',\n        setup(build) {\n          build.onResolve({ filter: /.*/, }, args => {\n            const hasAtSign = args.path.startsWith('@');\n            const isPackage = hasAtSign ?\n              allPackagesIncludingNode.includes(args.path) :\n              allPackagesIncludingNode.includes(args.path.split('/').shift());\n            if (args.importer && !isPackage) {\n              // If we're doing an index import we need /index.js\n              const calculatedDir = path.join(args.resolveDir, args.path);\n              let existsAsFile = false;\n              for (const extension of extensions) {\n                const asFile = calculatedDir + extension;\n                const exists = fs.existsSync(asFile);\n                if (exists) existsAsFile = true;\n              }\n              let outputPath = args.path + (existsAsFile ? '' : '/index') + '.js';\n              outputPath = args.path.endsWith('.js') || args.path.endsWith('.mjs') ? args.path : outputPath;\n              return { path: outputPath, external: true, };\n            }\n          });\n        },\n      },\n      {\n        name: 'insert-html-banner-and-remove-client-scripts',\n        setup(build) {\n          build.onLoad({ filter: /.tsx/, }, args => {\n            const cleanedContent = removeClientScriptInTSXFile(args.path);\n            const htmlImportStart = 'import { html } from \\'xpine\\';\\n';\n            const newContent = `${htmlImportStart}${cleanedContent.content}`;\n            componentData.push({\n              ...args,\n              contents: `${htmlImportStart}${cleanedContent.fullContent}`,\n              clientContent: cleanedContent.clientContent,\n            });\n            return {\n              contents: newContent,\n              loader: 'tsx',\n            };\n          });\n        },\n      },\n      {\n        name: 'get-data-files',\n        setup(build) {\n          build.onLoad({ filter: /\\.data\\.(js|mjs|ts)$/, }, args => {\n            const contents = fs.readFileSync(args.path, 'utf-8');\n            dataFiles.push({\n              ...args,\n              contents,\n            });\n            return {\n              contents,\n              loader: 'ts',\n            };\n          });\n        },\n      }\n    ],\n  });\n  await logSize(config.distDir, 'app');\n  return {\n    componentData,\n    dataFiles,\n  };\n}\n\n// Build client side files\nasync function buildClientSideFiles(alpineDataFiles: string[] = [], isDev?: boolean) {\n  // Write the temp file to use\n  const tempFilePath = path.join(config.distTempFolder, './app.ts');\n  fs.ensureFileSync(tempFilePath);\n  // Get all ts/js files in public folder but ignore the pages scripts\n  const pagesScriptsGlob = config.publicDir + '/scripts/pages/**/*.{js,ts}';\n  const clientFiles = globSync(\n    config.publicDir + '/**/*.{js,ts}',\n    {\n      ignore: pagesScriptsGlob,\n    }\n  );\n  // Filter out all public/pages files\n  convertEntryPointsToSingleFile(alpineDataFiles.concat(clientFiles), tempFilePath);\n  // Write dev server code to the temp file path\n  if (isDev) writeDevServerClientSideCode(tempFilePath);\n  // Write spa functionality to the temp file path\n  writeSpaClientSideCode(tempFilePath);\n  await build({\n    entryPoints: [tempFilePath],\n    bundle: true,\n    outdir: config.distPublicScriptsDir,\n    minify: !isDev,\n    sourcemap: isDev ? 'inline' : false,\n  });\n  // Build pages files scripts\n  const pagesFiles = globSync(pagesScriptsGlob);\n  await build({\n    entryPoints: pagesFiles || [],\n    bundle: true,\n    outdir: config.distPublicScriptsDir + '/pages',\n    minify: !isDev,\n    sourcemap: isDev ? 'inline' : false,\n  });\n  await logSize(config.distPublicDir, 'client');\n}\n\nfunction writeDevServerClientSideCode(tempFilePath: string) {\n  const devServerPath = path.join(import.meta.dirname, '../static/dev-server.js');\n  const content = fs.readFileSync(devServerPath, 'utf-8');\n  fs.appendFileSync(tempFilePath, `\\n` + content);\n}\n\nfunction writeSpaClientSideCode(tempFilePath: string) {\n  const spaPath = path.join(import.meta.dirname, '../static/spa.js');\n  const content = fs.readFileSync(spaPath, 'utf-8');\n  fs.appendFileSync(tempFilePath, `\\n` + content);\n}\n\nasync function buildAlpineDataFile(componentData: any[], dataFiles: any[]) {\n  const output = {\n    imports: [\n      'import Alpine from \\'alpinejs\\';'\n    ],\n    code: [],\n    end: [\n      'window.Alpine = Alpine;'\n    ],\n  };\n  const dataFunctionResults = {\n    foundDataAttributes: [],\n    foundFunctions: [],\n    foundImports: [],\n  };\n  const componentsAndDataFiles = componentData.concat(dataFiles);\n  for (const component of componentsAndDataFiles) {\n    // Single source file\n    const sourceFile = ts.createSourceFile(\n      component.path,\n      component.contents,\n      ts.ScriptTarget.Latest\n    );\n    const dataFunctionResult = findDataAttributesAndFunctions(sourceFile, sourceFile);\n    dataFunctionResults.foundDataAttributes.push(...dataFunctionResult.foundDataAttributes);\n    const foundFunctionsWithPath = dataFunctionResult.foundFunctions.map(item => {\n      return {\n        ...item,\n        path: component.path,\n        content: component.clientContent,\n      };\n    });\n    dataFunctionResults.foundFunctions.push(...foundFunctionsWithPath);\n  }\n  const validDataFunctions = dataFunctionResults.foundFunctions.filter(item => {\n    return dataFunctionResults.foundDataAttributes.includes(item.name) && item.content;\n  });\n  for (const dataFunction of validDataFunctions) {\n    if (!dataFunction.hasExport) continue;\n    output.code.push(dataFunction.content);\n    output.code.push(`Alpine.data('${dataFunction.name}', ${dataFunction.name});`);\n  }\n  const result = output.imports.join('\\n') + '\\n' + output.code.join('\\n') + '\\n' + output.end.join('\\n');\n  fs.ensureFileSync(config.alpineDataPath);\n  fs.writeFileSync(config.alpineDataPath, result);\n  return config.alpineDataPath;\n}\n\nexport async function buildCSS() {\n  const cssFiles = globSync(config.srcDir + '/**/*.css');\n  for (const file of cssFiles) {\n    const fileContents = fs.readFileSync(file, 'utf-8');\n    const result = await postcss([tailwindPostcss()]).process(fileContents, { from: file, });\n    // Write to dist folder\n    const newPath = file.replace(config.srcDir, config.distDir);\n    fs.ensureFileSync(newPath);\n    fs.writeFileSync(newPath, result.css);\n  }\n  logSize(config.distPublicDir, 'css');\n}\n\n// We need to symlink the non CSS or JS files from the src/public folder into the dist folder\nexport async function buildPublicFolderSymlinks() {\n  const files = globSync(config.publicDir + '/**/*.*', {\n    ignore: '/**/*.{css,js,ts,tsx,jsx}',\n  });\n\n  // Create symlinks in dist directory\n  for (const file of files) {\n    try {\n      const newPath = file.replace(config.srcDir, config.distDir);\n      const splitNewPath = newPath.split('/');\n      splitNewPath.pop();\n      const newDir = splitNewPath.join('/');\n      fs.ensureDirSync(newDir);\n      fs.symlinkSync(file, newPath);\n    } catch { }\n  }\n}\n\ntype FileItem = {\n  file: string;\n  size: number;\n}\n\nexport async function logSize(pathName: string, type: 'app' | 'client' | 'css', validExtensions = ['.js', '.css']) {\n  const files = globSync(pathName + '/**/*' + (type === 'css' ? '.css' : ''));\n  const fileSizes = files.map((file) => {\n    if (!validExtensions.find(ext => file.endsWith(ext))) return false;\n    return {\n      file,\n      size: (fs.statSync(file).size) / (1024 * 1000),\n    };\n  }).filter(Boolean);\n  const totalSize = fileSizes.reduce((total, current: FileItem) => {\n    return current.size + total;\n  }, 0);\n  console.info(`[${totalSize.toFixed(3)} MB] Built ${type}`);\n}\n", "import ts from 'typescript';\nimport fs from 'fs-extra';\nimport path from 'path';\n\ntype ImportDeclaration = {\n  node: ts.Node;\n  importPath: string;\n}\n\n// node arg should initially be the source node\nexport function getImportDeclarationNodes(node: ts.Node, sourceFile: ts.SourceFile, importDeclarations: ImportDeclaration[] = []) {\n  if (node.kind === ts.SyntaxKind.ImportDeclaration) {\n    let importPath = null;\n    node.forEachChild(child => {\n      if (child.kind === ts.SyntaxKind.StringLiteral) {\n        importPath = child.getText(sourceFile).replace(/[\\\"\\']/g, '');\n      }\n    });\n    importDeclarations.push({\n      node,\n      importPath,\n    });\n  }\n  node.forEachChild(child => {\n    getImportDeclarationNodes(child, sourceFile, importDeclarations);\n  });\n  return importDeclarations;\n}\n\nexport function stripImportsNodesFromFile(importsToStrip: string[], content: string, importDeclarations: ImportDeclaration[]) {\n  let outputContent = content;\n  const filteredImports = importDeclarations.filter(item => importsToStrip.includes(item.importPath));\n  for (const importItem of filteredImports) {\n    outputContent = outputContent.slice(0, importItem.node.pos) + outputContent.slice(importItem.node.end);\n  }\n  return outputContent;\n}\n\ntype FoundAlpineFunction = {\n  name: string;\n  isDefaultExport: boolean;\n  hasExport: boolean;\n}\n\nexport function findDataAttributesAndFunctions(\n  node: ts.Node,\n  sourceFile: ts.SourceFile,\n  foundDataAttributes: string[] = [],\n  foundFunctions: FoundAlpineFunction[] = []\n) {\n  if (node.kind === ts.SyntaxKind.JsxAttribute) {\n    const attribute = getAttributeValuePair(node, sourceFile);\n    if (attribute?.[0] === 'x-data' && attribute?.[1]) {\n      // We found a data attribute, \n      // so now we have to search throughout the file for a function declaration of the same name\n      foundDataAttributes.push(attribute[1].replace(/[^a-zA-Z0-9]/g, ''));\n    }\n  }\n  if (node.kind === ts.SyntaxKind.SourceFile) {\n    node.forEachChild(child => {\n      if ([ts.SyntaxKind.FunctionDeclaration, ts.SyntaxKind.VariableDeclaration].includes(child.kind)) {\n        const functions = getFunctionDeclarationValue(child, sourceFile);\n        foundFunctions.push(functions);\n      }\n    });\n  }\n\n  node.forEachChild(child => {\n    findDataAttributesAndFunctions(child, sourceFile, foundDataAttributes, foundFunctions);\n  });\n  return {\n    foundDataAttributes,\n    foundFunctions,\n  };\n}\n\nexport function getAttributeValuePair(node: ts.Node, sourceFile: ts.SourceFile): string[] {\n  const result = [];\n  node.forEachChild(child => {\n    result.push(child.getText(sourceFile));\n  });\n  return result;\n}\n\nexport function getFunctionDeclarationValue(node: ts.Node, sourceFile: ts.SourceFile): FoundAlpineFunction {\n  const result = {\n    name: null,\n    isDefaultExport: false,\n    hasExport: false,\n  };\n  node.forEachChild(child => {\n    if (child.kind === ts.SyntaxKind.ExportKeyword) {\n      result.hasExport = true;\n    }\n    if (child.kind === ts.SyntaxKind.DefaultKeyword) {\n      result.isDefaultExport = true;\n    }\n    if (child.kind === ts.SyntaxKind.Identifier) {\n      result.name = child.getText(sourceFile);\n    }\n  });\n  return result;\n}\n\n// Convert entry point files into one big bundle file\nexport function convertEntryPointsToSingleFile(entryPoints: string[], tempWritePath: string) {\n  fs.writeFileSync(\n    tempWritePath,\n    entryPoints\n      .map(entry => `import \"${entry}\"`)\n      .join(';\\n')\n  );\n}\n\nexport function removeClientScriptInTSXFile(pathName: string) {\n  const content = fs.readFileSync(pathName, 'utf-8');\n  const source = ts.createSourceFile(\n    pathName,\n    content,\n    ts.ScriptTarget.Latest\n  );\n  let toRemoveFrom: number;\n  let clientDataStart: number;\n  const clientImportsToHoist = [];\n  const clientImportsToReplace = [];\n  source.forEachChild((child) => {\n    if (child.kind === ts.SyntaxKind.ExpressionStatement) {\n      const text = child.getText(source);\n      // Remove from here\n      if (text.startsWith('<script')) {\n        toRemoveFrom = child.pos;\n        clientDataStart = child.end;\n      }\n    }\n    // Hoist the client imports to above the <script /> tag\n    if (child.kind === ts.SyntaxKind.ImportDeclaration && child.pos >= clientDataStart) {\n      const text = child.getText(source);\n      child.forEachChild(child => {\n        if (child.kind === ts.SyntaxKind.StringLiteral) {\n          // Keep track of client imports needed for path replacement to be absolute\n          const text = child.getText(source);\n          const importPath = text.replace(/[\\\"\\']/g, '');\n          const isRelativeImport = importPath.startsWith('.') || importPath.startsWith('/');\n          if (!isRelativeImport) return;\n          clientImportsToReplace.push({\n            old: importPath,\n            new: path.join(path.dirname(pathName), importPath),\n          });\n        }\n      });\n      clientImportsToHoist.push(text);\n    }\n  });\n  let clientContent = !isNaN(clientDataStart) ? content.slice(clientDataStart) : '';\n  for (const clientImport of clientImportsToReplace) {\n    clientContent = clientContent.replace(clientImport.old, clientImport.new);\n  }\n  return {\n    content: !isNaN(toRemoveFrom) ?\n      clientImportsToHoist.join('\\n') + content.slice(0, toRemoveFrom) :\n      content,\n    clientContent,\n    fullContent: content,\n    toRemoveFrom,\n    clientDataStart,\n  };\n}\n\nexport function printRecursiveFrom(\n  node: ts.Node, indentLevel: number, sourceFile: ts.SourceFile\n) {\n  const indentation = '-'.repeat(indentLevel);\n  const syntaxKind = ts.SyntaxKind[node.kind];\n  const nodeText = node.getText(sourceFile);\n  console.log(`${indentation}${syntaxKind}: ${nodeText}`);\n\n  node.forEachChild(child =>\n    printRecursiveFrom(child, indentLevel + 1, sourceFile)\n  );\n}\n", "import path from 'path';\nimport require from './require';\nimport { XPineConfig } from '../../types';\n\nconst rootDir = process.cwd();\n\nexport function fromRoot(pathName?: string) {\n  if (!pathName) return rootDir;\n  return path.join(rootDir, pathName);\n}\n\nconst userConfig = require(path.join(process.cwd(), './xpine.config.mjs')).default;\n\nconst configDefaults = {\n  rootDir: fromRoot(),\n  srcDir: fromRoot('./src'),\n  distDir: fromRoot('./dist'),\n  packageJsonPath: fromRoot('package.json'),\n  // We need to use getters here in the event someone wants to change folders, such as the dist folder\n  get distPublicDir() {\n    return path.join(this.distDir, './public');\n  },\n  get distPublicScriptsDir() {\n    return path.join(this.distPublicDir, './scripts');\n  },\n  get distTempFolder() {\n    return path.join(this.distDir, './temp');\n  },\n  get clientJSBundlePath() {\n    return path.join(this.distPublicScriptsDir, './app.js');\n  },\n  get alpineDataPath() {\n    return path.join(this.distTempFolder, './alpine-data.ts');\n  },\n  get serverDistDir() {\n    return path.join(this.distDir, './server');\n  },\n  get serverDistAppPath() {\n    return path.join(this.serverDistDir, './app.js');\n  },\n  // Important dirs/paths\n  get pagesDir() {\n    return path.join(this.srcDir, './pages');\n  },\n  get publicDir() {\n    return path.join(this.srcDir, './public');\n  },\n  get serverDir() {\n    return path.join(this.srcDir, './server');\n  },\n  get runDir() {\n    return path.join(this.serverDir, './run');\n  },\n  get serverAppPath() {\n    return path.join(this.serverDir, './app.ts');\n  },\n  get globalCSSFile() {\n    return path.join(this.publicDir, './styles/global.css');\n  },\n};\n\nexport const config: XPineConfig = {\n  ...configDefaults,\n  ...userConfig,\n};", "import { createRequire } from 'module';\n\nconst require = createRequire(import.meta.url);\n\nexport default require;", "import dotenv from 'dotenv';\nimport path from 'path';\nimport { config } from './get-config';\n\nexport function setupEnv() {\n  dotenv.config({ path: path.join(config.rootDir, `./.env.${process.env.STAGE || 'dev'}`),});\n}\n", "import express, { NextFunction, Express, Request, Response } from 'express';\nimport { globSync } from 'glob';\nimport { config } from './util/get-config';\nimport { verifyUser } from './auth';\nimport requestIP from 'request-ip';\nimport { ServerRequest } from '../types';\n\nconst doctypeHTML = '<!DOCTYPE html>';\n\nexport async function createRouter() {\n  const methods = ['get', 'post', 'put', 'patch', 'delete'];\n  const router = express.Router();\n  const routes = globSync(config.pagesDir + '/**/*.{tsx,ts}');\n  const routeMap = routes.map(route => {\n    return {\n      route: route.split(config.pagesDir).pop().replace('.tsx', '').replace('.js', '').replace('.ts', '').replace('/index', '/'),\n      path: route.replace(config.srcDir, config.distDir).replace('.tsx', '.js').replace('.ts', '.js'),\n      originalRoute: route,\n    };\n  });\n  const routeResults = [];\n\n  for (const route of routeMap) {\n    const isJSX = route.originalRoute.endsWith('.tsx') || route.originalRoute.endsWith('.jsx');\n    // Import route\n    const routeItem = process.env.NODE_ENV === 'development' ? null : (await import(route.path)).default;\n    // Configure result,methods for the route\n    const slugRoute = route.route.toLowerCase().replace(/[ ]/g, '');\n    const foundMethod = methods.find(method => slugRoute.endsWith(`.${method}`));\n    const isDynamicRoute = slugRoute.match(/\\[(.*)\\]/g);\n    let formattedRouteItem = slugRoute;\n    if (foundMethod) formattedRouteItem = formattedRouteItem.split('.').shift();\n    // Handle dynamic routing\n    if (isDynamicRoute) {\n      const result = [...formattedRouteItem.matchAll(/(\\[)(.*?)(\\])/g)];\n      for (const match of result) {\n        formattedRouteItem = formattedRouteItem.replace(match[0], ':' + match[2]);\n      }\n    }\n    // Push to the route results array\n    routeResults.push({\n      formattedRouteItem,\n      foundMethod,\n      route,\n    });\n    router[foundMethod || 'get'](formattedRouteItem, async (req: Request, res: Response) => {\n      try {\n        // Check if it's a string response from the routeItem or is a different response\n        if (routeItem) {\n          if (isJSX) {\n            res.send(doctypeHTML + (await routeItem(req, res)));\n          } else {\n            await routeItem(req, res);\n          }\n          return;\n        }\n        const defaultRouteImport = (await import(route.path + `?cache=${Date.now()}`)).default;\n        // Require every time only if in development mode\n        if (isJSX) {\n          res.send(doctypeHTML + (await defaultRouteImport(req, res)));\n        } else {\n          await defaultRouteImport(req, res);\n        }\n      } catch (err) {\n        console.error(err);\n        res.status(err?.status || 500).send(err?.message || 'Error');\n      }\n    });\n  }\n  return {\n    router,\n    routeResults,\n  };\n}\n\nasync function verifyUserMiddleware(req: ServerRequest, _res: Response, next: NextFunction) {\n  // @ts-ignore\n  const { usertoken, } = req.cookies;\n  if (!usertoken) {\n    req.user = null;\n  }\n  try {\n    const { user, } = await verifyUser(usertoken);\n    req.user = user;\n  } catch (err) {\n    req.user = null;\n  }\n  next();\n}\n\nexport async function createXPineRouter(app: any, beforeErrorRoute?: (app: Express) => void) {\n  app.use(express.static(config.distPublicDir));\n  app.use(verifyUserMiddleware);\n  app.use(requestIP.mw());\n\n  const { router, routeResults, } = await createRouter();\n  app.use(function replaceableRouter(req: Request, res: Response, next: NextFunction) {\n    router(req, res, next);\n  });\n\n  const found404 = routeResults?.find(item => item?.formattedRouteItem === '/404');\n  const import404 = process.env.NODE_ENV === 'development' ? null : (await import(found404.route.path)).default;\n\n  if (beforeErrorRoute) beforeErrorRoute(app);\n\n  // error handler\n  app.use(async function (req: Request, res: Response) {\n    // render the error page\n    res.status(404);\n\n    if (import404) {\n      res.send(doctypeHTML + (await import404(req, res)));\n    } else if (found404 && process.env.NODE_ENV === 'development') {\n      const import404Item = (await import(found404.route.path + `?cache=${Date.now()}`)).default\n      res.send(doctypeHTML + (await import404Item(req, res)));\n    } else {\n      res.send('Error');\n    }\n  });\n}", "import jsonwebtoken from 'jsonwebtoken';\nimport { ServerRequest } from '../types';\nconst { verify, sign, } = jsonwebtoken;\n\nexport async function signUser(email: string, username: string) {\n  return new Promise((resolve, reject) => {\n    sign(\n      {\n        user: {\n          email,\n          username,\n        },\n      },\n      // @ts-ignore\n      process.env.JWT_PRIVATE_KEY,\n      { expiresIn: '30d', },\n      (err, token) => {\n        if (err) reject(err);\n        resolve(token);\n      });\n  });\n}\n\nexport async function verifyUser(token: string): Promise<any> {\n  return new Promise((resolve, reject) => {\n    // @ts-ignore\n    verify(token, process.env.JWT_PRIVATE_KEY, (err, authorizedData) => {\n      if (err) reject(err);\n      resolve(authorizedData);\n    });\n  });\n}\n\nexport function getTokenFromRequest(req: ServerRequest) {\n  // @ts-ignore\n  const { authorization, } = req.headers;\n  if (!authorization) return null;\n  const token = authorization.split(' ').pop() || '';\n  return token || null;\n}", "export class html {\n\n  static attributeObjectToString(props) {\n    if (!props) return '';\n    return Object.entries(props)\n      .filter(([, value]) => value !== null && value !== undefined)\n      .map(([key, value], index) => {\n        const start = index === 0 ? ' ' : '';\n        return `${start}${key}=\"${value}\"`;\n      })\n      .join(' ');\n  }\n\n  static async fragment(props) {\n    const childrenResult = await Promise.all(props.children.flat());\n    return childrenResult.filter(Boolean).join('');\n  }\n\n  static async createElement(type, props, ...children) {\n    const childrenResult = await Promise.all(children.flat());\n    // Handle passing in another element\n    if (typeof type === 'function') {\n      const result = await type({ ...props, children: childrenResult, });\n      return result;\n    }\n    return `<${type}${this.attributeObjectToString(props)}>${childrenResult.filter(Boolean).join('')}</${type}>`;\n  }\n}\n\nexport function JSXRuntime() {\n  return true;\n}"],
  "mappings": "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",
  "names": ["path", "fs", "ts", "child", "text", "path", "require", "path", "fs", "build", "path", "ts", "path", "path", "path", "path", "startServer", "express", "globSync", "express", "globSync"]
}
