@eighty4/dank 0.0.4-2 → 0.0.4

package/lib_js/build.js

@@ -1,71 +1,57 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { createBuildTag } from "./build_tag.js";
+import { loadConfig } from "./config.js";
 import { createGlobalDefinitions } from "./define.js";
 import { esbuildWebpages, esbuildWorkers } from "./esbuild.js";
-import { resolveBuildFlags } from "./flags.js";
-import { HtmlEntrypoint } from "./html.js";
-import { WebsiteRegistry } from "./metadata.js";
 import { copyAssets } from "./public.js";
+import { WebsiteRegistry } from "./registry.js";
 async function buildWebsite(c) {
-  const build = resolveBuildFlags();
-  const buildTag = await createBuildTag(build);
-  console.log(build.minify ? build.production ? "minified production" : "minified" : "unminified", "build", buildTag, "building in ./build/dist");
-  await rm(build.dirs.buildRoot, { recursive: true, force: true });
-  await mkdir(build.dirs.buildDist, { recursive: true });
+  if (!c) {
+    c = await loadConfig("build", process.cwd());
+  }
+  const buildTag = await createBuildTag(c.flags);
+  console.log(c.flags.minify ? c.flags.production ? "minified production" : "minified" : "unminified", "build", buildTag, "building in ./build/dist");
+  await rm(c.dirs.buildRoot, { recursive: true, force: true });
+  await mkdir(c.dirs.buildDist, { recursive: true });
   for (const subdir of Object.keys(c.pages).filter((url) => url !== "/")) {
-    await mkdir(join(build.dirs.buildDist, subdir), { recursive: true });
+    await mkdir(join(c.dirs.buildDist, subdir), { recursive: true });
   }
-  await mkdir(join(build.dirs.buildRoot, "metafiles"), { recursive: true });
-  const registry = new WebsiteRegistry(build);
-  registry.pageUrls = Object.keys(c.pages);
-  registry.copiedAssets = await copyAssets(build);
-  await buildWebpages(c, registry, build, createGlobalDefinitions(build));
+  await mkdir(join(c.dirs.buildRoot, "metafiles"), { recursive: true });
+  const registry = await buildWebpages(c, createGlobalDefinitions(c));
   return await registry.writeManifest(buildTag);
 }
-async function buildWebpages(c, registry, build, define) {
-  const loadingEntryPoints = [];
-  const htmlEntrypoints = [];
-  for (const [urlPath, mapping] of Object.entries(c.pages)) {
-    const fsPath = typeof mapping === "string" ? mapping : mapping.webpage;
-    const html = new HtmlEntrypoint(build, registry.resolver, urlPath, fsPath);
-    loadingEntryPoints.push(new Promise((res) => html.on("entrypoints", res)));
-    htmlEntrypoints.push(html);
-  }
-  const uniqueEntryPoints = /* @__PURE__ */ new Set();
-  const buildEntryPoints = [];
-  for (const pageEntryPoints of await Promise.all(loadingEntryPoints)) {
-    for (const entryPoint of pageEntryPoints) {
-      if (!uniqueEntryPoints.has(entryPoint.in)) {
-        buildEntryPoints.push(entryPoint);
-      }
-    }
-  }
-  await esbuildWebpages(build, registry, define, buildEntryPoints, c.esbuild);
-  const workerEntryPoints = registry.workerEntryPoints();
+async function buildWebpages(c, define) {
+  const registry = new WebsiteRegistry(c);
+  registry.configSync();
+  registry.copiedAssets = await copyAssets(c.dirs);
+  await Promise.all(registry.htmlEntrypoints.map((html) => html.process()));
+  await esbuildWebpages(registry, define, registry.webpageEntryPoints);
+  const workerEntryPoints = registry.workerEntryPoints;
   if (workerEntryPoints?.length) {
-    await esbuildWorkers(build, registry, define, workerEntryPoints, c.esbuild);
+    await esbuildWorkers(registry, define, workerEntryPoints);
   }
-  await rewriteWorkerUrls(build, registry);
-  await Promise.all(htmlEntrypoints.map(async (html) => {
-    await writeFile(join(build.dirs.buildDist, html.url, "index.html"), html.output(registry));
+  await rewriteWorkerUrls(c.dirs, registry);
+  await Promise.all(registry.htmlEntrypoints.map(async (html) => {
+    await writeFile(join(c.dirs.buildDist, html.url, "index.html"), html.output(registry));
   }));
+  return registry;
 }
-async function rewriteWorkerUrls(build, registry) {
-  const workers = registry.workers();
+async function rewriteWorkerUrls(dirs, registry) {
+  const workers = registry.workers;
   if (!workers) {
     return;
   }
   const dependentBundlePaths = workers.map((w) => registry.mappedHref(w.dependentEntryPoint));
   const bundleOutputs = {};
   const readingFiles = Promise.all(dependentBundlePaths.map(async (p) => {
-    bundleOutputs[p] = await readFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), "utf8");
+    bundleOutputs[p] = await readFile(join(dirs.projectRootAbs, dirs.buildDist, p), "utf8");
   }));
   const rewriteChains = {};
   for (const p of dependentBundlePaths)
     rewriteChains[p] = [];
   for (const w of workers) {
-    rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push((s) => s.replace(createWorkerRegex(w.workerUrlPlaceholder), `new Worker('${registry.mappedHref(w.workerEntryPoint)}')`));
+    rewriteChains[registry.mappedHref(w.dependentEntryPoint)].push((s) => s.replace(createWorkerRegex(w.workerCtor, w.workerUrlPlaceholder), `new ${w.workerCtor}('${registry.mappedHref(w.workerEntryPoint)}')`));
   }
   await readingFiles;
   await Promise.all(Object.entries(bundleOutputs).map(async ([p, content]) => {
@@ -73,11 +59,11 @@ async function rewriteWorkerUrls(build, registry) {
     for (const rewriteFn of rewriteChains[p]) {
       result = rewriteFn(result);
     }
-    await writeFile(join(build.dirs.projectRootAbs, build.dirs.buildDist, p), result);
+    await writeFile(join(dirs.projectRootAbs, dirs.buildDist, p), result);
   }));
 }
-function createWorkerRegex(workerUrl) {
-  return new RegExp(`new(?:\\s|\\r?\\n)+Worker(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, "g");
+function createWorkerRegex(workerCtor, workerUrl) {
+  return new RegExp(`new(?:\\s|\\r?\\n)+${workerCtor}(?:\\s|\\r?\\n)*\\((?:\\s|\\r?\\n)*['"]${workerUrl}['"](?:\\s|\\r?\\n)*\\)`, "g");
 }
 export {
   buildWebsite,

package/lib_js/build_tag.js

@@ -1,11 +1,11 @@
 import { exec } from "node:child_process";
-async function createBuildTag(build) {
+async function createBuildTag(flags) {
   const now = /* @__PURE__ */ new Date();
   const ms = now.getUTCMilliseconds() + now.getUTCSeconds() * 1e3 + now.getUTCMinutes() * 1e3 * 60 + now.getUTCHours() * 1e3 * 60 * 60;
   const date = now.toISOString().substring(0, 10);
   const time = String(ms).padStart(8, "0");
   const when = `${date}-${time}`;
-  if (build.production) {
+  if (flags.production) {
     const gitHash = await new Promise((res, rej) => exec("git rev-parse --short HEAD", (err, stdout) => {
       if (err)
         rej(err);

package/lib_js/config.js

@@ -1,5 +1,6 @@
 import { isAbsolute, resolve } from "node:path";
-import { isProductionBuild } from "./flags.js";
+import { defaultProjectDirs } from "./dirs.js";
+import { resolveFlags as lookupDankFlags } from "./flags.js";
 var __rewriteRelativeImportExtension = function(path, preserveJsx) {
   if (typeof path === "string" && /^\.\.?\//.test(path)) {
     return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
@@ -8,31 +9,90 @@ var __rewriteRelativeImportExtension = function(path, preserveJsx) {
   }
   return path;
 };
-const CFG_P = "./dank.config.ts";
-async function loadConfig(mode, path = CFG_P) {
-  const modulePath = resolveConfigPath(path);
-  const c = await resolveConfig(mode, modulePath);
-  normalizePagePaths(c.pages);
+const DEFAULT_DEV_PORT = 3e3;
+const DEFAULT_PREVIEW_PORT = 4e3;
+const DEFAULT_ESBUILD_PORT = 3995;
+const DEFAULT_CONFIG_PATH = "./dank.config.ts";
+async function loadConfig(mode, projectRootAbs) {
+  if (!isAbsolute(projectRootAbs)) {
+    throw Error();
+  }
+  const modulePath = resolve(projectRootAbs, DEFAULT_CONFIG_PATH);
+  const dirs = await defaultProjectDirs(projectRootAbs);
+  const c = new DankConfigInternal(mode, modulePath, dirs);
+  await c.reload();
   return c;
 }
-function resolveConfigPath(path) {
-  if (isAbsolute(path)) {
-    return path;
-  } else {
-    return resolve(process.cwd(), path);
+class DankConfigInternal {
+  #dirs;
+  #flags;
+  #mode;
+  #modulePath;
+  #dankPort = DEFAULT_DEV_PORT;
+  #esbuildPort = DEFAULT_ESBUILD_PORT;
+  #esbuild;
+  #pages = {};
+  #devPages;
+  #services;
+  constructor(mode, modulePath, dirs) {
+    this.#dirs = dirs;
+    this.#flags = lookupDankFlags();
+    this.#mode = mode;
+    this.#modulePath = modulePath;
+  }
+  get dankPort() {
+    return this.#dankPort;
+  }
+  get esbuildPort() {
+    return this.#esbuildPort;
+  }
+  get esbuild() {
+    return this.#esbuild;
+  }
+  get dirs() {
+    return this.#dirs;
+  }
+  get flags() {
+    return this.#flags;
+  }
+  get mode() {
+    return this.#mode;
+  }
+  get pages() {
+    return this.#pages;
+  }
+  get devPages() {
+    return this.#devPages;
+  }
+  get services() {
+    return this.#services;
+  }
+  async reload() {
+    const userConfig = await resolveConfig(this.#modulePath, resolveDankDetails(this.#mode, this.#flags));
+    this.#dankPort = resolveDankPort(this.#flags, userConfig);
+    this.#esbuildPort = resolveEsbuildPort(this.#flags, userConfig);
+    this.#esbuild = Object.freeze(userConfig.esbuild);
+    this.#pages = Object.freeze(normalizePages(userConfig.pages));
+    this.#devPages = Object.freeze(userConfig.devPages);
+    this.#services = Object.freeze(userConfig.services);
   }
 }
-async function resolveConfig(mode, modulePath) {
+function resolveDankPort(flags, userConfig) {
+  return flags.dankPort || (flags.preview ? userConfig.previewPort || userConfig.port || DEFAULT_PREVIEW_PORT : userConfig.port || DEFAULT_DEV_PORT);
+}
+function resolveEsbuildPort(flags, userConfig) {
+  return flags.esbuildPort || userConfig.esbuild?.port || DEFAULT_ESBUILD_PORT;
+}
+async function resolveConfig(modulePath, details) {
   const module = await import(__rewriteRelativeImportExtension(`${modulePath}?${Date.now()}`));
-  const c = typeof module.default === "function" ? await module.default(resolveDankDetails(mode)) : module.default;
+  const c = typeof module.default === "function" ? await module.default(details) : module.default;
   validateDankConfig(c);
   return c;
 }
-function resolveDankDetails(mode) {
-  const production = isProductionBuild();
+function resolveDankDetails(mode, flags) {
   return {
-    dev: !production,
-    production,
+    dev: !flags.production,
+    production: flags.production,
     mode
   };
 }
@@ -40,6 +100,7 @@ function validateDankConfig(c) {
   try {
     validatePorts(c);
     validatePages(c.pages);
+    validateDevPages(c.devPages);
     validateDevServices(c.services);
     validateEsbuildConfig(c.esbuild);
   } catch (e) {
@@ -96,6 +157,29 @@ function validatePages(pages) {
     throw Error(`DankConfig.pages['${urlPath}'] must configure an html file`);
   }
 }
+function validateDevPages(devPages) {
+  if (devPages) {
+    for (const [urlPath, mapping] of Object.entries(devPages)) {
+      if (!urlPath.startsWith("/__")) {
+        throw Error(`DankConfig.devPages['${urlPath}'] must start \`${urlPath}\` with a \`/__\` path prefix`);
+      }
+      if (typeof mapping === "string") {
+        if (!mapping.endsWith(".html")) {
+          throw Error(`DankConfig.devPages['${urlPath}'] must configure an html file or DevPageMapping config`);
+        }
+      } else if (typeof mapping === "object") {
+        if (typeof mapping.label !== "string" || !mapping.label.length) {
+          throw Error(`DankConfig.devPages['${urlPath}'].label must declare a label`);
+        }
+        if (typeof mapping.webpage !== "string" || !mapping.webpage.endsWith(".html")) {
+          throw Error(`DankConfig.devPages['${urlPath}'].webpage must configure an html file`);
+        }
+      } else {
+        throw Error(`DankConfig.devPages['${urlPath}'] must be a DevPageMapping config with \`label\` and \`webpage\` values`);
+      }
+    }
+  }
+}
 function validatePageMapping(urlPath, mapping) {
   if (mapping.webpage === null || typeof mapping.webpage !== "string" || !mapping.webpage.endsWith(".html")) {
     throw Error(`DankConfig.pages['${urlPath}'].webpage must configure an html file`);
@@ -144,20 +228,15 @@ function validateDevServices(services) {
     }
   }
 }
-function normalizePagePaths(pages) {
+function normalizePages(pages) {
+  const result = {};
   for (const [pageUrl, mapping] of Object.entries(pages)) {
-    if (typeof mapping === "string") {
-      pages[pageUrl] = normalizePagePath(mapping);
-    } else {
-      mapping.webpage = normalizePagePath(mapping.webpage);
-    }
+    const mappedMapping = typeof mapping === "string" ? { webpage: mapping } : mapping;
+    mappedMapping.webpage = mappedMapping.webpage.replace(/^\.\//, "");
+    result[pageUrl] = mappedMapping;
   }
-}
-function normalizePagePath(p) {
-  return p.replace(/^\.\//, "");
+  return result;
 }
 export {
-  loadConfig,
-  resolveConfig,
-  resolveConfigPath
+  loadConfig
 };

package/lib_js/define.js

@@ -1,7 +1,7 @@
-function createGlobalDefinitions(build) {
+function createGlobalDefinitions(c) {
   return {
-    "dank.IS_DEV": JSON.stringify(!build.production),
-    "dank.IS_PROD": JSON.stringify(build.production)
+    "dank.IS_DEV": JSON.stringify(!c.flags.production),
+    "dank.IS_PROD": JSON.stringify(c.flags.production)
   };
 }
 export {

package/lib_js/dirs.js

@@ -0,0 +1,61 @@
+import { realpath } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { cwd } from "node:process";
+async function defaultProjectDirs(projectRootAbs) {
+  if (!projectRootAbs) {
+    projectRootAbs = cwd();
+  } else if (!isAbsolute(projectRootAbs)) {
+    throw Error();
+  }
+  const projectResolved = await realpath(projectRootAbs);
+  const pages = "pages";
+  const pagesResolved = join(projectResolved, pages);
+  return Object.freeze({
+    buildRoot: "build",
+    buildDist: join("build", "dist"),
+    buildWatch: join("build", "watch"),
+    pages,
+    pagesResolved,
+    projectResolved,
+    projectRootAbs,
+    public: "public"
+  });
+}
+class Resolver {
+  #dirs;
+  constructor(dirs) {
+    this.#dirs = dirs;
+  }
+  // cross platform safe absolute path resolution from pages dir
+  absPagesPath(...p) {
+    return join(this.#dirs.projectRootAbs, this.#dirs.pages, ...p);
+  }
+  // cross platform safe absolute path resolution from project root
+  absProjectPath(...p) {
+    return join(this.#dirs.projectRootAbs, ...p);
+  }
+  // `p` is expected to be a relative path resolvable from the project dir
+  isProjectSubpathInPagesDir(p) {
+    return resolve(join(this.#dirs.projectResolved, p)).startsWith(this.#dirs.pagesResolved);
+  }
+  // `p` is expected to be a relative path resolvable from the pages dir
+  isPagesSubpathInPagesDir(p) {
+    return this.isProjectSubpathInPagesDir(join(this.#dirs.pages, p));
+  }
+  // resolve a pages subpath from a resource within the pages directory by a relative href
+  // `from` is expected to be a pages resource fs path starting with `pages/` and ending with filename
+  // the result will be a pages subpath and will not have the pages dir prefix
+  // returns 'outofbounds' if the relative path does not resolve to a file within the pages dir
+  resolveHrefInPagesDir(from, href) {
+    const p = join(dirname(from), href);
+    if (this.isProjectSubpathInPagesDir(p)) {
+      return p;
+    } else {
+      return "outofbounds";
+    }
+  }
+}
+export {
+  Resolver,
+  defaultProjectDirs
+};

package/lib_js/errors.js

@@ -0,0 +1,9 @@
+class DankError extends Error {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "DankError";
+  }
+}
+export {
+  DankError
+};

package/lib_js/esbuild.js

@@ -1,37 +1,37 @@
 import { readFile } from "node:fs/promises";
 import esbuild, {} from "esbuild";
-async function esbuildDevContext(b, r, define, entryPoints, c) {
+async function esbuildDevContext(r, define, entryPoints) {
   return await esbuild.context({
     define,
     entryNames: "[dir]/[name]",
     entryPoints: mapEntryPointPaths(entryPoints),
-    outdir: b.dirs.buildWatch,
-    ...commonBuildOptions(b, r, c),
+    outdir: r.config.dirs.buildWatch,
+    ...commonBuildOptions(r),
     splitting: false,
     write: false
   });
 }
-async function esbuildWebpages(b, r, define, entryPoints, c) {
+async function esbuildWebpages(r, define, entryPoints) {
   try {
     await esbuild.build({
       define,
       entryNames: "[dir]/[name]-[hash]",
       entryPoints: mapEntryPointPaths(entryPoints),
-      outdir: b.dirs.buildDist,
-      ...commonBuildOptions(b, r, c)
+      outdir: r.config.dirs.buildDist,
+      ...commonBuildOptions(r)
     });
   } catch (ignore) {
     process.exit(1);
   }
 }
-async function esbuildWorkers(b, r, define, entryPoints, c) {
+async function esbuildWorkers(r, define, entryPoints) {
   try {
     await esbuild.build({
       define,
       entryNames: "[dir]/[name]-[hash]",
       entryPoints: mapEntryPointPaths(entryPoints),
-      outdir: b.dirs.buildDist,
-      ...commonBuildOptions(b, r, c),
+      outdir: r.config.dirs.buildDist,
+      ...commonBuildOptions(r),
       splitting: false,
       metafile: true,
       write: true,
@@ -41,18 +41,17 @@ async function esbuildWorkers(b, r, define, entryPoints, c) {
     process.exit(1);
   }
 }
-function commonBuildOptions(b, r, c) {
+function commonBuildOptions(r) {
   const p = workersPlugin(r.buildRegistry());
   return {
-    absWorkingDir: b.dirs.projectRootAbs,
     assetNames: "assets/[name]-[hash]",
     bundle: true,
     format: "esm",
-    loader: c?.loaders || defaultLoaders(),
+    loader: r.config.esbuild?.loaders || defaultLoaders(),
     metafile: true,
-    minify: b.minify,
+    minify: r.config.flags.minify,
     platform: "browser",
-    plugins: c?.plugins?.length ? [p, ...c.plugins] : [p],
+    plugins: r.config.esbuild?.plugins?.length ? [p, ...r.config.esbuild?.plugins] : [p],
     splitting: true,
     treeShaking: true,
     write: true
@@ -78,11 +77,8 @@ function workersPlugin(r) {
   return {
     name: "@eighty4/dank/esbuild/workers",
     setup(build) {
-      if (!build.initialOptions.absWorkingDir)
-        throw TypeError("plugin requires absWorkingDir");
       if (!build.initialOptions.metafile)
         throw TypeError("plugin requires metafile");
-      const { absWorkingDir } = build.initialOptions;
       build.onLoad({ filter: /\.(t|m?j)s$/ }, async (args) => {
         let contents = await readFile(args.path, "utf8");
         let offset = 0;
@@ -97,7 +93,7 @@ function workersPlugin(r) {
           if (isIndexCommented(contents, workerCtorMatch.index)) {
             continue;
           }
-          const clientScript = args.path.replace(absWorkingDir, "").substring(1);
+          const clientScript = args.path.replace(r.dirs.projectResolved, "").substring(1);
           const workerUrl = workerCtorMatch.groups.url.substring(1, workerCtorMatch.groups.url.length - 1);
           const workerEntryPoint = r.resolver.resolveHrefInPagesDir(clientScript, workerUrl);
           if (workerEntryPoint === "outofbounds") {
@@ -106,13 +102,15 @@ function workersPlugin(r) {
             errors.push(outofboundsWorkerUrlCtorArg(locationFromMatch(args, contents, workerCtorMatch), workerCtorMatch));
             continue;
           }
+          const workerCtor = workerCtorMatch.groups.ctor;
           const workerUrlPlaceholder = workerEntryPoint.replace(/^pages/, "").replace(/\.(t|m?j)s$/, ".js");
-          const workerCtorReplacement = `new ${workerCtorMatch.groups.ctor}('${workerUrlPlaceholder}'${workerCtorMatch.groups.end}`;
+          const workerCtorReplacement = `new ${workerCtor}('${workerUrlPlaceholder}'${workerCtorMatch.groups.end}`;
           contents = contents.substring(0, workerCtorMatch.index + offset) + workerCtorReplacement + contents.substring(workerCtorMatch.index + workerCtorMatch[0].length + offset);
           offset += workerCtorReplacement.length - workerCtorMatch[0].length;
           r.addWorker({
             clientScript,
             workerEntryPoint,
+            workerCtor,
             workerUrl,
             workerUrlPlaceholder
           });

package/lib_js/flags.js

@@ -1,71 +1,24 @@
-import { join, resolve } from "node:path";
-import { cwd } from "node:process";
-function resolveBuildFlags() {
-  const flags = {
-    dirs: defaultProjectDirs(cwd()),
-    minify: willMinify(),
-    production: isProductionBuild()
-  };
-  return {
-    get dirs() {
-      return flags.dirs;
-    },
-    get minify() {
-      return flags.minify;
-    },
-    get production() {
-      return flags.production;
-    }
-  };
-}
-function resolveServeFlags(c) {
-  const preview = isPreviewBuild();
-  const flags = {
-    dirs: defaultProjectDirs(cwd()),
-    dankPort: dankPort(c, preview),
-    esbuildPort: esbuildPort(c),
+function resolveFlags() {
+  return Object.freeze({
+    dankPort: resolveDankPort(),
+    esbuildPort: resolveEsbuildPort(),
     logHttp: willLogHttp(),
     minify: willMinify(),
-    preview,
+    preview: isPreviewBuild(),
     production: isProductionBuild()
-  };
-  return {
-    get dirs() {
-      return flags.dirs;
-    },
-    get dankPort() {
-      return flags.dankPort;
-    },
-    get esbuildPort() {
-      return flags.esbuildPort;
-    },
-    get logHttp() {
-      return flags.logHttp;
-    },
-    get minify() {
-      return flags.minify;
-    },
-    get preview() {
-      return flags.preview;
-    },
-    get production() {
-      return flags.production;
-    }
-  };
+  });
 }
 const isPreviewBuild = () => process.env.PREVIEW === "true" || process.argv.includes("--preview");
 const isProductionBuild = () => process.env.PRODUCTION === "true" || process.argv.includes("--production");
-function dankPort(c, preview) {
+function resolveDankPort() {
   if (process.env.DANK_PORT?.length) {
     return parsePortEnvVar("DANK_PORT");
   }
-  return preview ? c.previewPort || c.port || 4e3 : c.port || 3e3;
 }
-function esbuildPort(c) {
+function resolveEsbuildPort() {
   if (process.env.ESBUILD_PORT?.length) {
     return parsePortEnvVar("ESBUILD_PORT");
   }
-  return c.esbuild?.port || 3995;
 }
 function parsePortEnvVar(name) {
   const port = parseInt(process.env[name], 10);
@@ -75,50 +28,8 @@ function parsePortEnvVar(name) {
     return port;
   }
 }
-function defaultProjectDirs(projectRootAbs) {
-  const pages = "pages";
-  const dirs = {
-    buildRoot: "build",
-    buildDist: join("build", "dist"),
-    buildWatch: join("build", "watch"),
-    pages,
-    pagesResolved: resolve(join(projectRootAbs, pages)),
-    projectResolved: resolve(projectRootAbs),
-    projectRootAbs,
-    public: "public"
-  };
-  return {
-    get buildRoot() {
-      return dirs.buildRoot;
-    },
-    get buildDist() {
-      return dirs.buildDist;
-    },
-    get buildWatch() {
-      return dirs.buildWatch;
-    },
-    get pages() {
-      return dirs.pages;
-    },
-    get pagesResolved() {
-      return dirs.pagesResolved;
-    },
-    get projectResolved() {
-      return dirs.projectResolved;
-    },
-    get projectRootAbs() {
-      return dirs.projectRootAbs;
-    },
-    get public() {
-      return dirs.public;
-    }
-  };
-}
 const willMinify = () => isProductionBuild() || process.env.MINIFY === "true" || process.argv.includes("--minify");
 const willLogHttp = () => process.env.LOG_HTTP === "true" || process.argv.includes("--log-http");
 export {
-  defaultProjectDirs,
-  isProductionBuild,
-  resolveBuildFlags,
-  resolveServeFlags
+  resolveFlags
 };