xpine 0.0.4 → 0.0.6

package/dist/src/build/spa.js

@@ -0,0 +1,152 @@
+// src/build/spa.mjs
+async function replaceDocumentContentsWithLinkResponse() {
+  const links = [...document.querySelectorAll("[data-spa]")];
+  for (const link of links) {
+    link.addEventListener("click", updatePageOnLinkClick);
+  }
+}
+async function updatePageOnLinkClick(e) {
+  const targetHref = e?.target?.getAttribute("href");
+  if (!targetHref) return;
+  if (isExternalURL(targetHref) && !e?.target?.getAttribute("data-spa-crossorigin")) return;
+  e.preventDefault();
+  try {
+    await getNewPageContent(targetHref);
+    if (targetHref === window.location.pathname) return;
+    window.history.pushState(
+      {
+        type: "link-click",
+        targetHref
+      },
+      "",
+      targetHref
+    );
+    const event = new CustomEvent("spa:updatePageURL", {
+      detail: {
+        href: targetHref
+      }
+    });
+    window.dispatchEvent(event);
+  } catch (err) {
+    console.error(err);
+  }
+}
+async function getNewPageContent(href) {
+  try {
+    const res = await fetch(href);
+    const text = await res.text();
+    const parser = new DOMParser();
+    const dom = parser.parseFromString(text, "text/html");
+    diffHead(dom);
+    const newScripts = removeBodyScripts(dom);
+    const clonedPersistentNodes = getPersistentNodesFromDocument(dom);
+    const body = dom.body.innerHTML;
+    document.body.innerHTML = body;
+    for (const clonedNode of clonedPersistentNodes) {
+      const newNode = document.body.querySelector(`[data-persistent="${clonedNode?.getAttribute("data-persistent")}"]`);
+      newNode.replaceWith(clonedNode);
+    }
+    replaceAttributesOnDocumentBody(dom);
+    replaceDocumentContentsWithLinkResponse();
+    for (const script of newScripts) document.body.appendChild(script);
+    const event = new CustomEvent("spa:updatePageContent", {
+      detail: {
+        href
+      }
+    });
+    window.dispatchEvent(event);
+  } catch (err) {
+    console.error(err);
+    console.error("Error getting link", href);
+  }
+}
+function diffHead(dom) {
+  const domHeadChildren = [...dom.head.children];
+  const currentHeadChildren = [...document.head.children];
+  const result = {
+    childrenToAdd: [],
+    childrenToRemove: []
+  };
+  for (const domChild of domHeadChildren) {
+    const foundInCurrentChildren = currentHeadChildren.find((child) => child.outerHTML === domChild.outerHTML);
+    if (!foundInCurrentChildren) result.childrenToAdd.push(domChild);
+  }
+  for (const currentChild of currentHeadChildren) {
+    const foundInDomChildren = domHeadChildren.find((child) => child.outerHTML === currentChild.outerHTML);
+    if (!foundInDomChildren) result.childrenToRemove.push(currentChild);
+  }
+  applyHeadDiffsToDocument(result);
+}
+function applyHeadDiffsToDocument(diff) {
+  for (const child of diff.childrenToRemove) {
+    document.head.removeChild(child);
+  }
+  for (const child of diff.childrenToAdd) {
+    if (child?.nodeName?.toLowerCase() == "script") {
+      const scriptElement = document.createElement("script");
+      portAttributesToElement(child, scriptElement);
+      scriptElement.innerHTML = child.innerHTML;
+      document.head.appendChild(scriptElement);
+      continue;
+    }
+    document.head.appendChild(child);
+  }
+}
+function removeBodyScripts(dom) {
+  const scripts = [...dom.body.querySelectorAll("script")];
+  const newElements = [];
+  for (const script of scripts) {
+    const element = document.createElement("script");
+    portAttributesToElement(script, element);
+    element.innerHTML = script.innerHTML;
+    dom.body.removeChild(script);
+    newElements.push(element);
+  }
+  return newElements;
+}
+function portAttributesToElement(oldEl, newEl) {
+  for (const attribute of oldEl.attributes) {
+    newEl.setAttribute(attribute.name, attribute.nodeValue);
+  }
+}
+function getPersistentNodesFromDocument(dom) {
+  const persistentNodesFromDom = [...dom.querySelectorAll("[data-persistent]")].map((el) => el.getAttribute("data-persistent"));
+  const persistentNodesFromBody = [...document.body.querySelectorAll("[data-persistent]")];
+  const validPersistentNodes = persistentNodesFromBody.filter((el) => {
+    return persistentNodesFromDom.includes(el.getAttribute("data-persistent"));
+  });
+  return validPersistentNodes.map((el) => el.cloneNode(true));
+}
+function replaceAttributesOnDocumentBody(dom) {
+  while (document.body.attributes.length > 0) {
+    document.body.removeAttribute(document.body.attributes[0].name);
+  }
+  for (const attribute of dom.body.attributes) {
+    document.body.setAttribute(attribute.name, attribute.nodeValue);
+  }
+}
+async function handleBackButton() {
+  await getNewPageContent(window.history.state?.targetHref || window.location.href);
+}
+function isRelativeURL(url) {
+  if (typeof url !== "string") return false;
+  try {
+    new URL(url);
+    return false;
+  } catch (err) {
+    if (url?.startsWith("//")) return false;
+    return true;
+  }
+}
+function isExternalURL(url) {
+  if (isRelativeURL(url)) return false;
+  try {
+    const computedURL = new URL(url);
+    return computedURL?.origin !== window.location?.origin;
+  } catch {
+    return false;
+  }
+}
+window.addEventListener("DOMContentLoaded", replaceDocumentContentsWithLinkResponse);
+window.addEventListener("popstate", handleBackButton);
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/build/spa.mjs"],
  "sourcesContent": ["// Enables SPA like behavior for links\n\nasync function replaceDocumentContentsWithLinkResponse() {\n  const links = [...document.querySelectorAll('[data-spa]')];\n  for (const link of links) {\n    link.addEventListener('click', updatePageOnLinkClick);\n  }\n\n}\n\nasync function updatePageOnLinkClick(e) {\n  const targetHref = e?.target?.getAttribute('href');\n  if (!targetHref) return;\n  if (isExternalURL(targetHref) && !e?.target?.getAttribute('data-spa-crossorigin')) return;\n  e.preventDefault();\n  try {\n    await getNewPageContent(targetHref);\n    if (targetHref === window.location.pathname) return;\n    window.history.pushState(\n      {\n        type: 'link-click',\n        targetHref,\n      },\n      '',\n      targetHref\n    );\n    const event = new CustomEvent('spa:updatePageURL', {\n      detail: {\n        href: targetHref,\n      },\n    });\n    window.dispatchEvent(event);\n  } catch (err) {\n    console.error(err);\n  }\n}\n\nasync function getNewPageContent(href) {\n  try {\n    const res = await fetch(href);\n    const text = await res.text();\n    const parser = new DOMParser();\n    const dom = parser.parseFromString(text, 'text/html');\n    diffHead(dom);\n    const newScripts = removeBodyScripts(dom);\n    const clonedPersistentNodes = getPersistentNodesFromDocument(dom);\n    const body = dom.body.innerHTML;\n    document.body.innerHTML = body;\n    for (const clonedNode of clonedPersistentNodes) {\n      // @ts-ignore\n      const newNode = document.body.querySelector(`[data-persistent=\"${clonedNode?.getAttribute('data-persistent')}\"]`);\n      newNode.replaceWith(clonedNode);\n    }\n    replaceAttributesOnDocumentBody(dom);\n    replaceDocumentContentsWithLinkResponse();\n    for (const script of newScripts) document.body.appendChild(script);\n    // Send an event\n    const event = new CustomEvent('spa:updatePageContent', {\n      detail: {\n        href,\n      },\n    });\n    window.dispatchEvent(event);\n  } catch (err) {\n    console.error(err);\n    console.error('Error getting link', href);\n  }\n}\n\nfunction diffHead(dom) {\n  const domHeadChildren = [...dom.head.children];\n  const currentHeadChildren = [...document.head.children];\n  const result = {\n    childrenToAdd: [],\n    childrenToRemove: [],\n  };\n  for (const domChild of domHeadChildren) {\n    const foundInCurrentChildren = currentHeadChildren.find(child => child.outerHTML === domChild.outerHTML);\n    if (!foundInCurrentChildren) result.childrenToAdd.push(domChild);\n  }\n  for (const currentChild of currentHeadChildren) {\n    const foundInDomChildren = domHeadChildren.find(child => child.outerHTML === currentChild.outerHTML);\n    if (!foundInDomChildren) result.childrenToRemove.push(currentChild);\n  }\n  applyHeadDiffsToDocument(result);\n}\n\nfunction applyHeadDiffsToDocument(diff) {\n  for (const child of diff.childrenToRemove) {\n    // Remove from head\n    document.head.removeChild(child);\n  }\n  for (const child of diff.childrenToAdd) {\n    // Handle script tags\n    if (child?.nodeName?.toLowerCase() == 'script') {\n      const scriptElement = document.createElement('script');\n      portAttributesToElement(child, scriptElement);\n      scriptElement.innerHTML = child.innerHTML;\n      document.head.appendChild(scriptElement);\n      continue;\n    }\n    // Add to the head\n    document.head.appendChild(child);\n  }\n}\n\nfunction removeBodyScripts(dom) {\n  const scripts = [...dom.body.querySelectorAll('script')];\n  const newElements = [];\n  for (const script of scripts) {\n    const element = document.createElement('script');\n    portAttributesToElement(script, element);\n    element.innerHTML = script.innerHTML;\n    dom.body.removeChild(script);\n    newElements.push(element);\n  }\n  return newElements;\n}\n\nfunction portAttributesToElement(oldEl, newEl) {\n  for (const attribute of oldEl.attributes) {\n    newEl.setAttribute(attribute.name, attribute.nodeValue);\n  }\n}\n\nfunction getPersistentNodesFromDocument(dom) {\n  // Find persistent nodes\n  const persistentNodesFromDom = [...dom.querySelectorAll('[data-persistent]')].map(el => el.getAttribute('data-persistent'));\n  const persistentNodesFromBody = [...document.body.querySelectorAll('[data-persistent]')];\n  // Cross match the persistent nodes between current page and new page to find valid ones\n  const validPersistentNodes = persistentNodesFromBody.filter(el => {\n    return persistentNodesFromDom.includes(el.getAttribute('data-persistent'));\n  });\n  // Clone\n  return validPersistentNodes.map(el => el.cloneNode(true));\n}\n\nfunction replaceAttributesOnDocumentBody(dom) {\n  while (document.body.attributes.length > 0) {\n    document.body.removeAttribute(document.body.attributes[0].name);\n  }\n  // Set attributes on the body\n  for (const attribute of dom.body.attributes) {\n    document.body.setAttribute(attribute.name, attribute.nodeValue);\n  }\n}\n\nasync function handleBackButton() {\n  await getNewPageContent(window.history.state?.targetHref || window.location.href);\n}\n\nfunction isRelativeURL(url) {\n  if (typeof url !== 'string') return false;\n  try {\n    new URL(url);\n    return false;\n  } catch (err) {\n    if (url?.startsWith('//')) return false;\n    return true;\n  }\n}\n\nfunction isExternalURL(url) {\n  if (isRelativeURL(url)) return false;\n  try {\n    const computedURL = new URL(url);\n    return computedURL?.origin !== window.location?.origin;\n  } catch {\n    return false; // Not a URL\n  }\n}\n\nwindow.addEventListener('DOMContentLoaded', replaceDocumentContentsWithLinkResponse);\nwindow.addEventListener('popstate', handleBackButton);\n\n"],
  "mappings": ";AAEA,eAAe,0CAA0C;AACvD,QAAM,QAAQ,CAAC,GAAG,SAAS,iBAAiB,YAAY,CAAC;AACzD,aAAW,QAAQ,OAAO;AACxB,SAAK,iBAAiB,SAAS,qBAAqB;AAAA,EACtD;AAEF;AAEA,eAAe,sBAAsB,GAAG;AACtC,QAAM,aAAa,GAAG,QAAQ,aAAa,MAAM;AACjD,MAAI,CAAC,WAAY;AACjB,MAAI,cAAc,UAAU,KAAK,CAAC,GAAG,QAAQ,aAAa,sBAAsB,EAAG;AACnF,IAAE,eAAe;AACjB,MAAI;AACF,UAAM,kBAAkB,UAAU;AAClC,QAAI,eAAe,OAAO,SAAS,SAAU;AAC7C,WAAO,QAAQ;AAAA,MACb;AAAA,QACE,MAAM;AAAA,QACN;AAAA,MACF;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,UAAM,QAAQ,IAAI,YAAY,qBAAqB;AAAA,MACjD,QAAQ;AAAA,QACN,MAAM;AAAA,MACR;AAAA,IACF,CAAC;AACD,WAAO,cAAc,KAAK;AAAA,EAC5B,SAAS,KAAK;AACZ,YAAQ,MAAM,GAAG;AAAA,EACnB;AACF;AAEA,eAAe,kBAAkB,MAAM;AACrC,MAAI;AACF,UAAM,MAAM,MAAM,MAAM,IAAI;AAC5B,UAAM,OAAO,MAAM,IAAI,KAAK;AAC5B,UAAM,SAAS,IAAI,UAAU;AAC7B,UAAM,MAAM,OAAO,gBAAgB,MAAM,WAAW;AACpD,aAAS,GAAG;AACZ,UAAM,aAAa,kBAAkB,GAAG;AACxC,UAAM,wBAAwB,+BAA+B,GAAG;AAChE,UAAM,OAAO,IAAI,KAAK;AACtB,aAAS,KAAK,YAAY;AAC1B,eAAW,cAAc,uBAAuB;AAE9C,YAAM,UAAU,SAAS,KAAK,cAAc,qBAAqB,YAAY,aAAa,iBAAiB,CAAC,IAAI;AAChH,cAAQ,YAAY,UAAU;AAAA,IAChC;AACA,oCAAgC,GAAG;AACnC,4CAAwC;AACxC,eAAW,UAAU,WAAY,UAAS,KAAK,YAAY,MAAM;AAEjE,UAAM,QAAQ,IAAI,YAAY,yBAAyB;AAAA,MACrD,QAAQ;AAAA,QACN;AAAA,MACF;AAAA,IACF,CAAC;AACD,WAAO,cAAc,KAAK;AAAA,EAC5B,SAAS,KAAK;AACZ,YAAQ,MAAM,GAAG;AACjB,YAAQ,MAAM,sBAAsB,IAAI;AAAA,EAC1C;AACF;AAEA,SAAS,SAAS,KAAK;AACrB,QAAM,kBAAkB,CAAC,GAAG,IAAI,KAAK,QAAQ;AAC7C,QAAM,sBAAsB,CAAC,GAAG,SAAS,KAAK,QAAQ;AACtD,QAAM,SAAS;AAAA,IACb,eAAe,CAAC;AAAA,IAChB,kBAAkB,CAAC;AAAA,EACrB;AACA,aAAW,YAAY,iBAAiB;AACtC,UAAM,yBAAyB,oBAAoB,KAAK,WAAS,MAAM,cAAc,SAAS,SAAS;AACvG,QAAI,CAAC,uBAAwB,QAAO,cAAc,KAAK,QAAQ;AAAA,EACjE;AACA,aAAW,gBAAgB,qBAAqB;AAC9C,UAAM,qBAAqB,gBAAgB,KAAK,WAAS,MAAM,cAAc,aAAa,SAAS;AACnG,QAAI,CAAC,mBAAoB,QAAO,iBAAiB,KAAK,YAAY;AAAA,EACpE;AACA,2BAAyB,MAAM;AACjC;AAEA,SAAS,yBAAyB,MAAM;AACtC,aAAW,SAAS,KAAK,kBAAkB;AAEzC,aAAS,KAAK,YAAY,KAAK;AAAA,EACjC;AACA,aAAW,SAAS,KAAK,eAAe;AAEtC,QAAI,OAAO,UAAU,YAAY,KAAK,UAAU;AAC9C,YAAM,gBAAgB,SAAS,cAAc,QAAQ;AACrD,8BAAwB,OAAO,aAAa;AAC5C,oBAAc,YAAY,MAAM;AAChC,eAAS,KAAK,YAAY,aAAa;AACvC;AAAA,IACF;AAEA,aAAS,KAAK,YAAY,KAAK;AAAA,EACjC;AACF;AAEA,SAAS,kBAAkB,KAAK;AAC9B,QAAM,UAAU,CAAC,GAAG,IAAI,KAAK,iBAAiB,QAAQ,CAAC;AACvD,QAAM,cAAc,CAAC;AACrB,aAAW,UAAU,SAAS;AAC5B,UAAM,UAAU,SAAS,cAAc,QAAQ;AAC/C,4BAAwB,QAAQ,OAAO;AACvC,YAAQ,YAAY,OAAO;AAC3B,QAAI,KAAK,YAAY,MAAM;AAC3B,gBAAY,KAAK,OAAO;AAAA,EAC1B;AACA,SAAO;AACT;AAEA,SAAS,wBAAwB,OAAO,OAAO;AAC7C,aAAW,aAAa,MAAM,YAAY;AACxC,UAAM,aAAa,UAAU,MAAM,UAAU,SAAS;AAAA,EACxD;AACF;AAEA,SAAS,+BAA+B,KAAK;AAE3C,QAAM,yBAAyB,CAAC,GAAG,IAAI,iBAAiB,mBAAmB,CAAC,EAAE,IAAI,QAAM,GAAG,aAAa,iBAAiB,CAAC;AAC1H,QAAM,0BAA0B,CAAC,GAAG,SAAS,KAAK,iBAAiB,mBAAmB,CAAC;AAEvF,QAAM,uBAAuB,wBAAwB,OAAO,QAAM;AAChE,WAAO,uBAAuB,SAAS,GAAG,aAAa,iBAAiB,CAAC;AAAA,EAC3E,CAAC;AAED,SAAO,qBAAqB,IAAI,QAAM,GAAG,UAAU,IAAI,CAAC;AAC1D;AAEA,SAAS,gCAAgC,KAAK;AAC5C,SAAO,SAAS,KAAK,WAAW,SAAS,GAAG;AAC1C,aAAS,KAAK,gBAAgB,SAAS,KAAK,WAAW,CAAC,EAAE,IAAI;AAAA,EAChE;AAEA,aAAW,aAAa,IAAI,KAAK,YAAY;AAC3C,aAAS,KAAK,aAAa,UAAU,MAAM,UAAU,SAAS;AAAA,EAChE;AACF;AAEA,eAAe,mBAAmB;AAChC,QAAM,kBAAkB,OAAO,QAAQ,OAAO,cAAc,OAAO,SAAS,IAAI;AAClF;AAEA,SAAS,cAAc,KAAK;AAC1B,MAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,MAAI;AACF,QAAI,IAAI,GAAG;AACX,WAAO;AAAA,EACT,SAAS,KAAK;AACZ,QAAI,KAAK,WAAW,IAAI,EAAG,QAAO;AAClC,WAAO;AAAA,EACT;AACF;AAEA,SAAS,cAAc,KAAK;AAC1B,MAAI,cAAc,GAAG,EAAG,QAAO;AAC/B,MAAI;AACF,UAAM,cAAc,IAAI,IAAI,GAAG;AAC/B,WAAO,aAAa,WAAW,OAAO,UAAU;AAAA,EAClD,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,OAAO,iBAAiB,oBAAoB,uCAAuC;AACnF,OAAO,iBAAiB,YAAY,gBAAgB;",
  "names": []
}


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

@@ -0,0 +1,420 @@
+#!/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();