xpine 0.0.3 → 0.0.5

package/dist/src/scripts/xpine-build.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+// 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/scripts/xpine-build.ts
+buildApp();
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/scripts/build.ts", "../../../src/build/typescript-builder.ts", "../../../src/util/get-config.ts", "../../../src/util/require.ts", "../../../src/scripts/xpine-build.ts"],
  "sourcesContent": ["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;", "#!/usr/bin/env node\n\nimport { buildApp } from './build';\n\nbuildApp();"],
  "mappings": "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",
  "names": ["path", "fs", "ts", "child", "text", "path", "require", "path", "fs", "build", "path", "ts"]
}
