xpine 0.0.5 → 0.0.7

package/src/build/typescript-builder.ts

@@ -1,180 +0,0 @@
-import ts from 'typescript';
-import fs from 'fs-extra';
-import path from 'path';
-
-type ImportDeclaration = {
-  node: ts.Node;
-  importPath: string;
-}
-
-// node arg should initially be the source node
-export function getImportDeclarationNodes(node: ts.Node, sourceFile: ts.SourceFile, importDeclarations: ImportDeclaration[] = []) {
-  if (node.kind === ts.SyntaxKind.ImportDeclaration) {
-    let importPath = null;
-    node.forEachChild(child => {
-      if (child.kind === ts.SyntaxKind.StringLiteral) {
-        importPath = child.getText(sourceFile).replace(/[\"\']/g, '');
-      }
-    });
-    importDeclarations.push({
-      node,
-      importPath,
-    });
-  }
-  node.forEachChild(child => {
-    getImportDeclarationNodes(child, sourceFile, importDeclarations);
-  });
-  return importDeclarations;
-}
-
-export function stripImportsNodesFromFile(importsToStrip: string[], content: string, importDeclarations: ImportDeclaration[]) {
-  let outputContent = content;
-  const filteredImports = importDeclarations.filter(item => importsToStrip.includes(item.importPath));
-  for (const importItem of filteredImports) {
-    outputContent = outputContent.slice(0, importItem.node.pos) + outputContent.slice(importItem.node.end);
-  }
-  return outputContent;
-}
-
-type FoundAlpineFunction = {
-  name: string;
-  isDefaultExport: boolean;
-  hasExport: boolean;
-}
-
-export function findDataAttributesAndFunctions(
-  node: ts.Node,
-  sourceFile: ts.SourceFile,
-  foundDataAttributes: string[] = [],
-  foundFunctions: FoundAlpineFunction[] = []
-) {
-  if (node.kind === ts.SyntaxKind.JsxAttribute) {
-    const attribute = getAttributeValuePair(node, sourceFile);
-    if (attribute?.[0] === 'x-data' && attribute?.[1]) {
-      // We found a data attribute, 
-      // so now we have to search throughout the file for a function declaration of the same name
-      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,
-  };
-}
-
-export function getAttributeValuePair(node: ts.Node, sourceFile: ts.SourceFile): string[] {
-  const result = [];
-  node.forEachChild(child => {
-    result.push(child.getText(sourceFile));
-  });
-  return result;
-}
-
-export function getFunctionDeclarationValue(node: ts.Node, sourceFile: ts.SourceFile): FoundAlpineFunction {
-  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;
-}
-
-// Convert entry point files into one big bundle file
-export function convertEntryPointsToSingleFile(entryPoints: string[], tempWritePath: string) {
-  fs.writeFileSync(
-    tempWritePath,
-    entryPoints
-      .map(entry => `import "${entry}"`)
-      .join(';\n')
-  );
-}
-
-export function removeClientScriptInTSXFile(pathName: string) {
-  const content = fs.readFileSync(pathName, 'utf-8');
-  const source = ts.createSourceFile(
-    pathName,
-    content,
-    ts.ScriptTarget.Latest
-  );
-  let toRemoveFrom: number;
-  let clientDataStart: number;
-  const clientImportsToHoist = [];
-  const clientImportsToReplace = [];
-  source.forEachChild((child) => {
-    if (child.kind === ts.SyntaxKind.ExpressionStatement) {
-      const text = child.getText(source);
-      // Remove from here
-      if (text.startsWith('<script')) {
-        toRemoveFrom = child.pos;
-        clientDataStart = child.end;
-      }
-    }
-    // Hoist the client imports to above the <script /> tag
-    if (child.kind === ts.SyntaxKind.ImportDeclaration && child.pos >= clientDataStart) {
-      const text = child.getText(source);
-      child.forEachChild(child => {
-        if (child.kind === ts.SyntaxKind.StringLiteral) {
-          // Keep track of client imports needed for path replacement to be absolute
-          const text = child.getText(source);
-          const importPath = text.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,
-  };
-}
-
-export function printRecursiveFrom(
-  node: ts.Node, indentLevel: number, sourceFile: ts.SourceFile
-) {
-  const indentation = '-'.repeat(indentLevel);
-  const syntaxKind = ts.SyntaxKind[node.kind];
-  const nodeText = node.getText(sourceFile);
-  console.log(`${indentation}${syntaxKind}: ${nodeText}`);
-
-  node.forEachChild(child =>
-    printRecursiveFrom(child, indentLevel + 1, sourceFile)
-  );
-}

package/src/express.ts

@@ -1,120 +0,0 @@
-import express, { NextFunction, Express, Request, Response } from 'express';
-import { globSync } from 'glob';
-import { config } from './util/get-config';
-import { verifyUser } from './auth';
-import requestIP from 'request-ip';
-import { ServerRequest } from '../types';
-
-const doctypeHTML = '<!DOCTYPE html>';
-
-export async function createRouter() {
-  const methods = ['get', 'post', 'put', 'patch', 'delete'];
-  const router = express.Router();
-  const routes = globSync(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');
-    // Import route
-    const routeItem = process.env.NODE_ENV === 'development' ? null : (await import(route.path)).default;
-    // Configure result,methods for the route
-    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();
-    // Handle dynamic routing
-    if (isDynamicRoute) {
-      const result = [...formattedRouteItem.matchAll(/(\[)(.*?)(\])/g)];
-      for (const match of result) {
-        formattedRouteItem = formattedRouteItem.replace(match[0], ':' + match[2]);
-      }
-    }
-    // Push to the route results array
-    routeResults.push({
-      formattedRouteItem,
-      foundMethod,
-      route,
-    });
-    router[foundMethod || 'get'](formattedRouteItem, async (req: Request, res: Response) => {
-      try {
-        // Check if it's a string response from the routeItem or is a different response
-        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;
-        // Require every time only if in development mode
-        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: ServerRequest, _res: Response, next: NextFunction) {
-  // @ts-ignore
-  const { usertoken, } = req.cookies;
-  if (!usertoken) {
-    req.user = null;
-  }
-  try {
-    const { user, } = await verifyUser(usertoken);
-    req.user = user;
-  } catch (err) {
-    req.user = null;
-  }
-  next();
-}
-
-export async function createXPineRouter(app: any, beforeErrorRoute?: (app: Express) => void) {
-  app.use(express.static(config.distPublicDir));
-  app.use(verifyUserMiddleware);
-  app.use(requestIP.mw());
-
-  const { router, routeResults, } = await createRouter();
-  app.use(function replaceableRouter(req: Request, res: Response, next: NextFunction) {
-    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);
-
-  // error handler
-  app.use(async function (req: Request, res: Response) {
-    // render the error page
-    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');
-    }
-  });
-}

package/src/runDevServer.ts

@@ -1,64 +0,0 @@
-import expressWs from 'express-ws';
-import http from 'http';
-import express from 'express';
-import EventEmitter from 'events';
-import chokidar from 'chokidar';
-import { buildApp } from './scripts/build';
-import path from 'path';
-import { config } from './util/get-config';
-import { setupEnv } from './util/env';
-
-setupEnv();
-
-export async function runDevServer() {
-  process.env.NODE_ENV = 'development';
-  const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
-
-  // Initial server set up
-  await buildApp(true);
-  let appServer = await startServer.default();
-
-  // Watch files
-  const watcher = chokidar.watch(config.srcDir, {
-    ignoreInitial: true,
-    // Ignore map and prisma files
-    ignored: (pathName) => pathName.endsWith('.map') || pathName.startsWith(path.join(config.serverDir, './prisma')),
-  });
-  watcher.on('all', async (event, path) => {
-    const shouldReloadServer = (path.startsWith(config.serverDir) && !path.startsWith(config.runDir)) ||
-      ['add', 'unlink'].includes(event) && path.startsWith(config.pagesDir);
-    if (shouldReloadServer) {
-      // We modified files in the server, restart the server
-      appServer.server.close();
-      await buildApp(true);
-      const startServer = await import(config.serverDistAppPath + `?cache=${Date.now()}`);
-      appServer = await startServer.default();
-      return;
-    }
-    await buildApp(true);
-    refreshEmitter.emit('refresh');
-  });
-
-  // Create web socket sever
-  const wsApp = express();
-  const wsServer = http.createServer(wsApp);
-  expressWs(wsApp, wsServer);
-  class RefreshEmitter extends EventEmitter { };
-  const refreshEmitter = new RefreshEmitter();
-
-  // @ts-ignore
-  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}`);
-  });
-}
-
-

package/src/scripts/build-module.ts

@@ -1,36 +0,0 @@
-import fs from 'fs-extra';
-import { build } from 'esbuild';
-import { config } from '../util/get-config';
-import path from 'path';
-
-// Extensions to look for in the bundle
-const packageJson = JSON.parse(fs.readFileSync(config.packageJsonPath, 'utf-8'));
-const allPackages = Object.keys(packageJson.devDependencies).concat(Object.keys(packageJson.dependencies));
-const dirname = import.meta.dirname;
-
-export async function buildXPine() {
-  await build({
-    entryPoints: [
-      // The contents of XPine itself
-      path.join(dirname, '../../index.ts'),
-      // The script for xpine-build
-      path.join(dirname, './xpine-build.ts'),
-      // The script for xpine-dev
-      path.join(dirname, './xpine-dev.ts'),
-      // Static files
-      path.join(dirname, '../static/dev-server.mjs'),
-      path.join(dirname, '../static/spa.mjs'),
-    ],
-    format: 'esm',
-    platform: 'node',
-    outdir: path.join(dirname, '../../dist'),
-    bundle: true,
-    sourcemap: 'inline',
-    external: allPackages,
-    jsx: 'transform',
-    minify: false,
-    plugins: [],
-  });
-}
-
-buildXPine();

package/src/scripts/build.ts

@@ -1,274 +0,0 @@
-import path from 'path';
-import fs from 'fs-extra';
-import { build } from 'esbuild';
-import builtinModules from 'builtin-modules';
-import ts from 'typescript';
-import {
-  convertEntryPointsToSingleFile,
-  findDataAttributesAndFunctions,
-  removeClientScriptInTSXFile
-} from '../build/typescript-builder';
-import { globSync } from 'glob';
-import postcss from 'postcss';
-// @ts-ignore
-import tailwindPostcss from '@tailwindcss/postcss';
-import { config } from '../util/get-config';
-
-// Extensions to look for in the bundle
-const extensions = ['.ts', '.tsx'];
-const packageJson = JSON.parse(fs.readFileSync(config.packageJsonPath, 'utf-8'));
-const allPackages = Object.keys(packageJson.devDependencies).concat(Object.keys(packageJson.dependencies));
-const allPackagesIncludingNode = allPackages.concat(builtinModules);
-
-export 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);
-    fs.removeSync(config.distTempFolder);
-    await buildCSS();
-    await buildPublicFolderSymlinks();
-  } catch (err) {
-    console.error('Build failed');
-    console.error(err);
-  }
-}
-
-async function buildAppFiles(files: string[], isDev?: boolean) {
-  const componentData = [];
-  const dataFiles = [];
-  // Filter out client side files and files that aren't of the allowed extensions
-  const backendFiles = files
-    .filter((file) => extensions.find(ext => file.endsWith(ext)))
-    .filter((file) => !file.startsWith(config.publicDir));
-  fs.ensureDirSync(config.distDir);
-  // Build backend/SSR TSX modules
-  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(build) {
-          build.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) {
-              // If we're doing an index import we need /index.js
-              const calculatedDir = path.join(args.resolveDir, args.path);
-              let existsAsFile = false;
-              for (const extension of extensions) {
-                const asFile = calculatedDir + extension;
-                const exists = fs.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(build) {
-          build.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(build) {
-          build.onLoad({ filter: /\.data\.(js|mjs|ts)$/, }, args => {
-            const contents = fs.readFileSync(args.path, 'utf-8');
-            dataFiles.push({
-              ...args,
-              contents,
-            });
-            return {
-              contents,
-              loader: 'ts',
-            };
-          });
-        },
-      }
-    ],
-  });
-  await logSize(config.distDir, 'app');
-  return {
-    componentData,
-    dataFiles,
-  };
-}
-
-// Build client side files
-async function buildClientSideFiles(alpineDataFiles: string[] = [], isDev?: boolean) {
-  // Write the temp file to use
-  const tempFilePath = path.join(config.distTempFolder, './app.ts');
-  fs.ensureFileSync(tempFilePath);
-  // Get all ts/js files in public folder but ignore the pages scripts
-  const pagesScriptsGlob = config.publicDir + '/scripts/pages/**/*.{js,ts}';
-  const clientFiles = globSync(
-    config.publicDir + '/**/*.{js,ts}',
-    {
-      ignore: pagesScriptsGlob,
-    }
-  );
-  // Filter out all public/pages files
-  convertEntryPointsToSingleFile(alpineDataFiles.concat(clientFiles), tempFilePath);
-  // Write dev server code to the temp file path
-  if (isDev) writeDevServerClientSideCode(tempFilePath);
-  // Write spa functionality to the temp file path
-  writeSpaClientSideCode(tempFilePath);
-  await build({
-    entryPoints: [tempFilePath],
-    bundle: true,
-    outdir: config.distPublicScriptsDir,
-    minify: !isDev,
-    sourcemap: isDev ? 'inline' : false,
-  });
-  // Build pages files scripts
-  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: string) {
-  const devServerPath = path.join(import.meta.dirname, '../static/dev-server.js');
-  const content = fs.readFileSync(devServerPath, 'utf-8');
-  fs.appendFileSync(tempFilePath, `\n` + content);
-}
-
-function writeSpaClientSideCode(tempFilePath: string) {
-  const spaPath = path.join(import.meta.dirname, '../static/spa.js');
-  const content = fs.readFileSync(spaPath, 'utf-8');
-  fs.appendFileSync(tempFilePath, `\n` + content);
-}
-
-async function buildAlpineDataFile(componentData: any[], dataFiles: any[]) {
-  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) {
-    // Single source file
-    const sourceFile = ts.createSourceFile(
-      component.path,
-      component.contents,
-      ts.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');
-  fs.ensureFileSync(config.alpineDataPath);
-  fs.writeFileSync(config.alpineDataPath, result);
-  return config.alpineDataPath;
-}
-
-export async function buildCSS() {
-  const cssFiles = globSync(config.srcDir + '/**/*.css');
-  for (const file of cssFiles) {
-    const fileContents = fs.readFileSync(file, 'utf-8');
-    const result = await postcss([tailwindPostcss()]).process(fileContents, { from: file, });
-    // Write to dist folder
-    const newPath = file.replace(config.srcDir, config.distDir);
-    fs.ensureFileSync(newPath);
-    fs.writeFileSync(newPath, result.css);
-  }
-  logSize(config.distPublicDir, 'css');
-}
-
-// We need to symlink the non CSS or JS files from the src/public folder into the dist folder
-export async function buildPublicFolderSymlinks() {
-  const files = globSync(config.publicDir + '/**/*.*', {
-    ignore: '/**/*.{css,js,ts,tsx,jsx}',
-  });
-
-  // Create symlinks in dist directory
-  for (const file of files) {
-    try {
-      const newPath = file.replace(config.srcDir, config.distDir);
-      const splitNewPath = newPath.split('/');
-      splitNewPath.pop();
-      const newDir = splitNewPath.join('/');
-      fs.ensureDirSync(newDir);
-      fs.symlinkSync(file, newPath);
-    } catch { }
-  }
-}
-
-type FileItem = {
-  file: string;
-  size: number;
-}
-
-export async function logSize(pathName: string, type: 'app' | 'client' | 'css', 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: (fs.statSync(file).size) / (1024 * 1000),
-    };
-  }).filter(Boolean);
-  const totalSize = fileSizes.reduce((total, current: FileItem) => {
-    return current.size + total;
-  }, 0);
-  console.info(`[${totalSize.toFixed(3)} MB] Built ${type}`);
-}

package/src/scripts/xpine-build.ts

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { buildApp } from './build';
-
-buildApp();

package/src/scripts/xpine-dev.ts

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-import { runDevServer } from '../runDevServer';
-
-runDevServer();

package/src/static/dev-server.mjs

@@ -1,9 +0,0 @@
-const socketProtocol = 'ws:';
-const echoSocketUrl = socketProtocol + '//' + window.location.hostname + ':3001/dev-server/';
-const socket = new WebSocket(echoSocketUrl);
-
-socket.addEventListener('message', async (msg) => {
-  if (msg.data === 'refresh:client') {
-    window.location.reload();
-  }
-});